# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.0
#
# 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
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _QuantLib
else:
    import _QuantLib

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

    def distance(self, x):
        return _QuantLib.SwigPyIterator_distance(self, x)

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

    def copy(self):
        return _QuantLib.SwigPyIterator_copy(self)

    def next(self):
        return _QuantLib.SwigPyIterator_next(self)

    def __next__(self):
        return _QuantLib.SwigPyIterator___next__(self)

    def previous(self):
        return _QuantLib.SwigPyIterator_previous(self)

    def advance(self, n):
        return _QuantLib.SwigPyIterator_advance(self, n)

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

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

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

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

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

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

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

SHARED_PTR_DISOWN = _QuantLib.SHARED_PTR_DISOWN

Sunday = _QuantLib.Sunday

Monday = _QuantLib.Monday

Tuesday = _QuantLib.Tuesday

Wednesday = _QuantLib.Wednesday

Thursday = _QuantLib.Thursday

Friday = _QuantLib.Friday

Saturday = _QuantLib.Saturday

January = _QuantLib.January

February = _QuantLib.February

March = _QuantLib.March

April = _QuantLib.April

May = _QuantLib.May

June = _QuantLib.June

July = _QuantLib.July

August = _QuantLib.August

September = _QuantLib.September

October = _QuantLib.October

November = _QuantLib.November

December = _QuantLib.December

Days = _QuantLib.Days

Weeks = _QuantLib.Weeks

Months = _QuantLib.Months

Years = _QuantLib.Years

Hours = _QuantLib.Hours

Minutes = _QuantLib.Minutes

Seconds = _QuantLib.Seconds

Milliseconds = _QuantLib.Milliseconds

Microseconds = _QuantLib.Microseconds

NoFrequency = _QuantLib.NoFrequency

Once = _QuantLib.Once

Annual = _QuantLib.Annual

Semiannual = _QuantLib.Semiannual

EveryFourthMonth = _QuantLib.EveryFourthMonth

Quarterly = _QuantLib.Quarterly

Bimonthly = _QuantLib.Bimonthly

Monthly = _QuantLib.Monthly

EveryFourthWeek = _QuantLib.EveryFourthWeek

Biweekly = _QuantLib.Biweekly

Weekly = _QuantLib.Weekly

Daily = _QuantLib.Daily

OtherFrequency = _QuantLib.OtherFrequency

class Period(object):
    r"""Proxy of C++ Period class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def length(self):
        r"""length(Period self) -> Integer"""
        return _QuantLib.Period_length(self)

    def units(self):
        r"""units(Period self) -> TimeUnit"""
        return _QuantLib.Period_units(self)

    def frequency(self):
        r"""frequency(Period self) -> Frequency"""
        return _QuantLib.Period_frequency(self)

    def normalized(self):
        r"""normalized(Period self) -> Period"""
        return _QuantLib.Period_normalized(self)

    def __init__(self, *args):
        r"""
        __init__(Period self) -> Period
        __init__(Period self, Integer n, TimeUnit units) -> Period
        __init__(Period self, Frequency arg2) -> Period
        __init__(Period self, std::string const & str) -> Period
        """
        _QuantLib.Period_swiginit(self, _QuantLib.new_Period(*args))

    def __str__(self):
        r"""__str__(Period self) -> std::string"""
        return _QuantLib.Period___str__(self)

    def __repr__(self):
        r"""__repr__(Period self) -> std::string"""
        return _QuantLib.Period___repr__(self)

    def __neg__(self):
        r"""__neg__(Period self) -> Period"""
        return _QuantLib.Period___neg__(self)

    def __add__(self, p):
        r"""__add__(Period self, Period p) -> Period"""
        return _QuantLib.Period___add__(self, p)

    def __sub__(self, p):
        r"""__sub__(Period self, Period p) -> Period"""
        return _QuantLib.Period___sub__(self, p)

    def __mul__(self, n):
        r"""__mul__(Period self, Integer n) -> Period"""
        return _QuantLib.Period___mul__(self, n)

    def __rmul__(self, n):
        r"""__rmul__(Period self, Integer n) -> Period"""
        return _QuantLib.Period___rmul__(self, n)

    def __lt__(self, other):
        r"""__lt__(Period self, Period other) -> bool"""
        return _QuantLib.Period___lt__(self, other)

    def __gt__(self, other):
        r"""__gt__(Period self, Period other) -> bool"""
        return _QuantLib.Period___gt__(self, other)

    def __le__(self, other):
        r"""__le__(Period self, Period other) -> bool"""
        return _QuantLib.Period___le__(self, other)

    def __ge__(self, other):
        r"""__ge__(Period self, Period other) -> bool"""
        return _QuantLib.Period___ge__(self, other)

    def __eq__(self, other):
        r"""__eq__(Period self, Period other) -> bool"""
        return _QuantLib.Period___eq__(self, other)

    def __cmp__(self, other):
        r"""__cmp__(Period self, Period other) -> int"""
        return _QuantLib.Period___cmp__(self, other)

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

    __swig_destroy__ = _QuantLib.delete_Period

# Register Period in _QuantLib:
_QuantLib.Period_swigregister(Period)
class PeriodVector(object):
    r"""Proxy of C++ std::vector< Period > class."""

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

    def iterator(self):
        r"""iterator(PeriodVector self) -> SwigPyIterator"""
        return _QuantLib.PeriodVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(PeriodVector self) -> bool"""
        return _QuantLib.PeriodVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(PeriodVector self) -> bool"""
        return _QuantLib.PeriodVector___bool__(self)

    def __len__(self):
        r"""__len__(PeriodVector self) -> std::vector< Period >::size_type"""
        return _QuantLib.PeriodVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j) -> PeriodVector"""
        return _QuantLib.PeriodVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j)
        __setslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j, PeriodVector v)
        """
        return _QuantLib.PeriodVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j)"""
        return _QuantLib.PeriodVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(PeriodVector self, std::vector< Period >::difference_type i)
        __delitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.PeriodVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice) -> PeriodVector
        __getitem__(PeriodVector self, std::vector< Period >::difference_type i) -> Period
        """
        return _QuantLib.PeriodVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice, PeriodVector v)
        __setitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(PeriodVector self, std::vector< Period >::difference_type i, Period x)
        """
        return _QuantLib.PeriodVector___setitem__(self, *args)

    def pop(self):
        r"""pop(PeriodVector self) -> Period"""
        return _QuantLib.PeriodVector_pop(self)

    def append(self, x):
        r"""append(PeriodVector self, Period x)"""
        return _QuantLib.PeriodVector_append(self, x)

    def empty(self):
        r"""empty(PeriodVector self) -> bool"""
        return _QuantLib.PeriodVector_empty(self)

    def size(self):
        r"""size(PeriodVector self) -> std::vector< Period >::size_type"""
        return _QuantLib.PeriodVector_size(self)

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

    def begin(self):
        r"""begin(PeriodVector self) -> std::vector< Period >::iterator"""
        return _QuantLib.PeriodVector_begin(self)

    def end(self):
        r"""end(PeriodVector self) -> std::vector< Period >::iterator"""
        return _QuantLib.PeriodVector_end(self)

    def rbegin(self):
        r"""rbegin(PeriodVector self) -> std::vector< Period >::reverse_iterator"""
        return _QuantLib.PeriodVector_rbegin(self)

    def rend(self):
        r"""rend(PeriodVector self) -> std::vector< Period >::reverse_iterator"""
        return _QuantLib.PeriodVector_rend(self)

    def clear(self):
        r"""clear(PeriodVector self)"""
        return _QuantLib.PeriodVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(PeriodVector self) -> std::vector< Period >::allocator_type"""
        return _QuantLib.PeriodVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(PeriodVector self)"""
        return _QuantLib.PeriodVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(PeriodVector self, std::vector< Period >::iterator pos) -> std::vector< Period >::iterator
        erase(PeriodVector self, std::vector< Period >::iterator first, std::vector< Period >::iterator last) -> std::vector< Period >::iterator
        """
        return _QuantLib.PeriodVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(PeriodVector self) -> PeriodVector
        __init__(PeriodVector self, PeriodVector other) -> PeriodVector
        __init__(PeriodVector self, std::vector< Period >::size_type size) -> PeriodVector
        __init__(PeriodVector self, std::vector< Period >::size_type size, Period value) -> PeriodVector
        """
        _QuantLib.PeriodVector_swiginit(self, _QuantLib.new_PeriodVector(*args))

    def push_back(self, x):
        r"""push_back(PeriodVector self, Period x)"""
        return _QuantLib.PeriodVector_push_back(self, x)

    def front(self):
        r"""front(PeriodVector self) -> Period"""
        return _QuantLib.PeriodVector_front(self)

    def back(self):
        r"""back(PeriodVector self) -> Period"""
        return _QuantLib.PeriodVector_back(self)

    def assign(self, n, x):
        r"""assign(PeriodVector self, std::vector< Period >::size_type n, Period x)"""
        return _QuantLib.PeriodVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(PeriodVector self, std::vector< Period >::size_type new_size)
        resize(PeriodVector self, std::vector< Period >::size_type new_size, Period x)
        """
        return _QuantLib.PeriodVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(PeriodVector self, std::vector< Period >::iterator pos, Period x) -> std::vector< Period >::iterator
        insert(PeriodVector self, std::vector< Period >::iterator pos, std::vector< Period >::size_type n, Period x)
        """
        return _QuantLib.PeriodVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(PeriodVector self, std::vector< Period >::size_type n)"""
        return _QuantLib.PeriodVector_reserve(self, n)

    def capacity(self):
        r"""capacity(PeriodVector self) -> std::vector< Period >::size_type"""
        return _QuantLib.PeriodVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_PeriodVector

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

import datetime as _datetime

class Date(object):
    r"""Proxy of C++ Date class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def weekday(self):
        r"""weekday(Date self) -> Weekday"""
        return _QuantLib.Date_weekday(self)

    def dayOfMonth(self):
        r"""dayOfMonth(Date self) -> Day"""
        return _QuantLib.Date_dayOfMonth(self)

    def dayOfYear(self):
        r"""dayOfYear(Date self) -> Day"""
        return _QuantLib.Date_dayOfYear(self)

    def month(self):
        r"""month(Date self) -> Month"""
        return _QuantLib.Date_month(self)

    def year(self):
        r"""year(Date self) -> Year"""
        return _QuantLib.Date_year(self)

    def hours(self):
        r"""hours(Date self) -> Hour"""
        return _QuantLib.Date_hours(self)

    def minutes(self):
        r"""minutes(Date self) -> Minute"""
        return _QuantLib.Date_minutes(self)

    def seconds(self):
        r"""seconds(Date self) -> Second"""
        return _QuantLib.Date_seconds(self)

    def milliseconds(self):
        r"""milliseconds(Date self) -> Millisecond"""
        return _QuantLib.Date_milliseconds(self)

    def microseconds(self):
        r"""microseconds(Date self) -> Microsecond"""
        return _QuantLib.Date_microseconds(self)

    def fractionOfDay(self):
        r"""fractionOfDay(Date self) -> Time"""
        return _QuantLib.Date_fractionOfDay(self)

    def fractionOfSecond(self):
        r"""fractionOfSecond(Date self) -> Time"""
        return _QuantLib.Date_fractionOfSecond(self)

    def serialNumber(self):
        r"""serialNumber(Date self) -> BigInteger"""
        return _QuantLib.Date_serialNumber(self)

    @staticmethod
    def isLeap(y):
        r"""isLeap(Year y) -> bool"""
        return _QuantLib.Date_isLeap(y)

    @staticmethod
    def minDate():
        r"""minDate() -> Date"""
        return _QuantLib.Date_minDate()

    @staticmethod
    def maxDate():
        r"""maxDate() -> Date"""
        return _QuantLib.Date_maxDate()

    @staticmethod
    def todaysDate():
        r"""todaysDate() -> Date"""
        return _QuantLib.Date_todaysDate()

    @staticmethod
    def localDateTime():
        r"""localDateTime() -> Date"""
        return _QuantLib.Date_localDateTime()

    @staticmethod
    def universalDateTime():
        r"""universalDateTime() -> Date"""
        return _QuantLib.Date_universalDateTime()

    @staticmethod
    def endOfMonth(arg1):
        r"""endOfMonth(Date arg1) -> Date"""
        return _QuantLib.Date_endOfMonth(arg1)

    @staticmethod
    def isEndOfMonth(arg1):
        r"""isEndOfMonth(Date arg1) -> bool"""
        return _QuantLib.Date_isEndOfMonth(arg1)

    @staticmethod
    def nextWeekday(arg1, arg2):
        r"""nextWeekday(Date arg1, Weekday arg2) -> Date"""
        return _QuantLib.Date_nextWeekday(arg1, arg2)

    @staticmethod
    def nthWeekday(n, arg2, m, y):
        r"""nthWeekday(Size n, Weekday arg2, Month m, Year y) -> Date"""
        return _QuantLib.Date_nthWeekday(n, arg2, m, y)

    def __add__(self, *args):
        r"""
        __add__(Date self, BigInteger days) -> Date
        __add__(Date self, Period arg2) -> Date
        """
        return _QuantLib.Date___add__(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Date self) -> Date
        __init__(Date self, Day d, Month m, Year y) -> Date
        __init__(Date self, Day d, Month m, Year y, Hour hours, Minute minutes, Second seconds, Millisecond millisec=0, Microsecond microsec=0) -> Date
        __init__(Date self, BigInteger serialNumber) -> Date
        __init__(Date self, std::string const & str, std::string fmt) -> Date
        """
        _QuantLib.Date_swiginit(self, _QuantLib.new_Date(*args))

    def weekdayNumber(self):
        r"""weekdayNumber(Date self) -> Integer"""
        return _QuantLib.Date_weekdayNumber(self)

    def __str__(self):
        r"""__str__(Date self) -> std::string"""
        return _QuantLib.Date___str__(self)

    def __repr__(self):
        r"""__repr__(Date self) -> std::string"""
        return _QuantLib.Date___repr__(self)

    def ISO(self):
        r"""ISO(Date self) -> std::string"""
        return _QuantLib.Date_ISO(self)

    def __sub__(self, *args):
        r"""
        __sub__(Date self, BigInteger days) -> Date
        __sub__(Date self, Period arg2) -> Date
        __sub__(Date self, Date other) -> BigInteger
        """
        return _QuantLib.Date___sub__(self, *args)

    def __eq__(self, other):
        r"""__eq__(Date self, Date other) -> bool"""
        return _QuantLib.Date___eq__(self, other)

    def __cmp__(self, other):
        r"""__cmp__(Date self, Date other) -> int"""
        return _QuantLib.Date___cmp__(self, other)

    def __nonzero__(self):
        r"""__nonzero__(Date self) -> bool"""
        return _QuantLib.Date___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Date self) -> bool"""
        return _QuantLib.Date___bool__(self)

    def __hash__(self):
        r"""__hash__(Date self) -> int"""
        return _QuantLib.Date___hash__(self)

    def __lt__(self, other):
        r"""__lt__(Date self, Date other) -> bool"""
        return _QuantLib.Date___lt__(self, other)

    def __gt__(self, other):
        r"""__gt__(Date self, Date other) -> bool"""
        return _QuantLib.Date___gt__(self, other)

    def __le__(self, other):
        r"""__le__(Date self, Date other) -> bool"""
        return _QuantLib.Date___le__(self, other)

    def __ge__(self, other):
        r"""__ge__(Date self, Date other) -> bool"""
        return _QuantLib.Date___ge__(self, other)

    def __ne__(self, other):
        r"""__ne__(Date self, Date other) -> bool"""
        return _QuantLib.Date___ne__(self, other)

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

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

    __swig_destroy__ = _QuantLib.delete_Date

# Register Date in _QuantLib:
_QuantLib.Date_swigregister(Date)
class DateParser(object):
    r"""Proxy of C++ DateParser class."""

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

    @staticmethod
    def parseFormatted(str, fmt):
        r"""parseFormatted(std::string const & str, std::string const & fmt) -> Date"""
        return _QuantLib.DateParser_parseFormatted(str, fmt)

    @staticmethod
    def parseISO(str):
        r"""parseISO(std::string const & str) -> Date"""
        return _QuantLib.DateParser_parseISO(str)

    @staticmethod
    def parse(str, fmt):
        r"""parse(std::string const & str, std::string fmt) -> Date"""
        return _QuantLib.DateParser_parse(str, fmt)

    def __init__(self):
        r"""__init__(DateParser self) -> DateParser"""
        _QuantLib.DateParser_swiginit(self, _QuantLib.new_DateParser())
    __swig_destroy__ = _QuantLib.delete_DateParser

# Register DateParser in _QuantLib:
_QuantLib.DateParser_swigregister(DateParser)
class PeriodParser(object):
    r"""Proxy of C++ PeriodParser class."""

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

    @staticmethod
    def parse(str):
        r"""parse(std::string const & str) -> Period"""
        return _QuantLib.PeriodParser_parse(str)

    def __init__(self):
        r"""__init__(PeriodParser self) -> PeriodParser"""
        _QuantLib.PeriodParser_swiginit(self, _QuantLib.new_PeriodParser())
    __swig_destroy__ = _QuantLib.delete_PeriodParser

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

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):
    r"""Proxy of C++ std::vector< Date > class."""

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

    def iterator(self):
        r"""iterator(DateVector self) -> SwigPyIterator"""
        return _QuantLib.DateVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DateVector self) -> bool"""
        return _QuantLib.DateVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DateVector self) -> bool"""
        return _QuantLib.DateVector___bool__(self)

    def __len__(self):
        r"""__len__(DateVector self) -> std::vector< Date >::size_type"""
        return _QuantLib.DateVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j) -> DateVector"""
        return _QuantLib.DateVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j)
        __setslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j, DateVector v)
        """
        return _QuantLib.DateVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j)"""
        return _QuantLib.DateVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DateVector self, std::vector< Date >::difference_type i)
        __delitem__(DateVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.DateVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DateVector self, SWIGPY_SLICEOBJECT * slice) -> DateVector
        __getitem__(DateVector self, std::vector< Date >::difference_type i) -> Date
        """
        return _QuantLib.DateVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DateVector self, SWIGPY_SLICEOBJECT * slice, DateVector v)
        __setitem__(DateVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(DateVector self, std::vector< Date >::difference_type i, Date x)
        """
        return _QuantLib.DateVector___setitem__(self, *args)

    def pop(self):
        r"""pop(DateVector self) -> Date"""
        return _QuantLib.DateVector_pop(self)

    def append(self, x):
        r"""append(DateVector self, Date x)"""
        return _QuantLib.DateVector_append(self, x)

    def empty(self):
        r"""empty(DateVector self) -> bool"""
        return _QuantLib.DateVector_empty(self)

    def size(self):
        r"""size(DateVector self) -> std::vector< Date >::size_type"""
        return _QuantLib.DateVector_size(self)

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

    def begin(self):
        r"""begin(DateVector self) -> std::vector< Date >::iterator"""
        return _QuantLib.DateVector_begin(self)

    def end(self):
        r"""end(DateVector self) -> std::vector< Date >::iterator"""
        return _QuantLib.DateVector_end(self)

    def rbegin(self):
        r"""rbegin(DateVector self) -> std::vector< Date >::reverse_iterator"""
        return _QuantLib.DateVector_rbegin(self)

    def rend(self):
        r"""rend(DateVector self) -> std::vector< Date >::reverse_iterator"""
        return _QuantLib.DateVector_rend(self)

    def clear(self):
        r"""clear(DateVector self)"""
        return _QuantLib.DateVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(DateVector self) -> std::vector< Date >::allocator_type"""
        return _QuantLib.DateVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DateVector self)"""
        return _QuantLib.DateVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DateVector self, std::vector< Date >::iterator pos) -> std::vector< Date >::iterator
        erase(DateVector self, std::vector< Date >::iterator first, std::vector< Date >::iterator last) -> std::vector< Date >::iterator
        """
        return _QuantLib.DateVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DateVector self) -> DateVector
        __init__(DateVector self, DateVector other) -> DateVector
        __init__(DateVector self, std::vector< Date >::size_type size) -> DateVector
        __init__(DateVector self, std::vector< Date >::size_type size, Date value) -> DateVector
        """
        _QuantLib.DateVector_swiginit(self, _QuantLib.new_DateVector(*args))

    def push_back(self, x):
        r"""push_back(DateVector self, Date x)"""
        return _QuantLib.DateVector_push_back(self, x)

    def front(self):
        r"""front(DateVector self) -> Date"""
        return _QuantLib.DateVector_front(self)

    def back(self):
        r"""back(DateVector self) -> Date"""
        return _QuantLib.DateVector_back(self)

    def assign(self, n, x):
        r"""assign(DateVector self, std::vector< Date >::size_type n, Date x)"""
        return _QuantLib.DateVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DateVector self, std::vector< Date >::size_type new_size)
        resize(DateVector self, std::vector< Date >::size_type new_size, Date x)
        """
        return _QuantLib.DateVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DateVector self, std::vector< Date >::iterator pos, Date x) -> std::vector< Date >::iterator
        insert(DateVector self, std::vector< Date >::iterator pos, std::vector< Date >::size_type n, Date x)
        """
        return _QuantLib.DateVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DateVector self, std::vector< Date >::size_type n)"""
        return _QuantLib.DateVector_reserve(self, n)

    def capacity(self):
        r"""capacity(DateVector self) -> std::vector< Date >::size_type"""
        return _QuantLib.DateVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DateVector

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

def daysBetween(arg1, arg2):
    r"""daysBetween(Date arg1, Date arg2) -> Time"""
    return _QuantLib.daysBetween(arg1, arg2)
class IMM(object):
    r"""Proxy of C++ IMM class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    F = _QuantLib.IMM_F
    
    G = _QuantLib.IMM_G
    
    H = _QuantLib.IMM_H
    
    J = _QuantLib.IMM_J
    
    K = _QuantLib.IMM_K
    
    M = _QuantLib.IMM_M
    
    N = _QuantLib.IMM_N
    
    Q = _QuantLib.IMM_Q
    
    U = _QuantLib.IMM_U
    
    V = _QuantLib.IMM_V
    
    X = _QuantLib.IMM_X
    
    Z = _QuantLib.IMM_Z
    

    @staticmethod
    def isIMMdate(d, mainCycle=True):
        r"""isIMMdate(Date d, bool mainCycle=True) -> bool"""
        return _QuantLib.IMM_isIMMdate(d, mainCycle)

    @staticmethod
    def isIMMcode(code, mainCycle=True):
        r"""isIMMcode(std::string const & code, bool mainCycle=True) -> bool"""
        return _QuantLib.IMM_isIMMcode(code, mainCycle)

    @staticmethod
    def code(immDate):
        r"""code(Date immDate) -> std::string"""
        return _QuantLib.IMM_code(immDate)

    @staticmethod
    def date(*args):
        r"""date(std::string const & immCode, Date referenceDate=Date()) -> Date"""
        return _QuantLib.IMM_date(*args)

    @staticmethod
    def nextDate(*args):
        r"""
        nextDate(Date d=Date(), bool mainCycle=True) -> Date
        nextDate(std::string const & immCode, bool mainCycle=True, Date referenceDate=Date()) -> Date
        """
        return _QuantLib.IMM_nextDate(*args)

    @staticmethod
    def nextCode(*args):
        r"""
        nextCode(Date d=Date(), bool mainCycle=True) -> std::string
        nextCode(std::string const & immCode, bool mainCycle=True, Date referenceDate=Date()) -> std::string
        """
        return _QuantLib.IMM_nextCode(*args)

    def __init__(self):
        r"""__init__(IMM self) -> IMM"""
        _QuantLib.IMM_swiginit(self, _QuantLib.new_IMM())
    __swig_destroy__ = _QuantLib.delete_IMM

# Register IMM in _QuantLib:
_QuantLib.IMM_swigregister(IMM)
class ASX(object):
    r"""Proxy of C++ ASX class."""

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

    @staticmethod
    def isASXdate(d, mainCycle=True):
        r"""isASXdate(Date d, bool mainCycle=True) -> bool"""
        return _QuantLib.ASX_isASXdate(d, mainCycle)

    @staticmethod
    def isASXcode(code, mainCycle=True):
        r"""isASXcode(std::string const & code, bool mainCycle=True) -> bool"""
        return _QuantLib.ASX_isASXcode(code, mainCycle)

    @staticmethod
    def code(asxDate):
        r"""code(Date asxDate) -> std::string"""
        return _QuantLib.ASX_code(asxDate)

    @staticmethod
    def date(*args):
        r"""date(std::string const & asxCode, Date referenceDate=Date()) -> Date"""
        return _QuantLib.ASX_date(*args)

    @staticmethod
    def nextDate(*args):
        r"""
        nextDate(Date d=Date(), bool mainCycle=True) -> Date
        nextDate(std::string const & asxCode, bool mainCycle=True, Date referenceDate=Date()) -> Date
        """
        return _QuantLib.ASX_nextDate(*args)

    @staticmethod
    def nextCode(*args):
        r"""
        nextCode(Date d=Date(), bool mainCycle=True) -> std::string
        nextCode(std::string const & asxCode, bool mainCycle=True, Date referenceDate=Date()) -> std::string
        """
        return _QuantLib.ASX_nextCode(*args)

    def __init__(self):
        r"""__init__(ASX self) -> ASX"""
        _QuantLib.ASX_swiginit(self, _QuantLib.new_ASX())
    __swig_destroy__ = _QuantLib.delete_ASX

# Register ASX in _QuantLib:
_QuantLib.ASX_swigregister(ASX)
class IntVector(object):
    r"""Proxy of C++ std::vector< int > class."""

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

    def iterator(self):
        r"""iterator(IntVector self) -> SwigPyIterator"""
        return _QuantLib.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IntVector self) -> bool"""
        return _QuantLib.IntVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IntVector self) -> bool"""
        return _QuantLib.IntVector___bool__(self)

    def __len__(self):
        r"""__len__(IntVector self) -> std::vector< int >::size_type"""
        return _QuantLib.IntVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> IntVector"""
        return _QuantLib.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, IntVector v)
        """
        return _QuantLib.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _QuantLib.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IntVector self, std::vector< int >::difference_type i)
        __delitem__(IntVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IntVector self, SWIGPY_SLICEOBJECT * slice) -> IntVector
        __getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _QuantLib.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IntVector self, SWIGPY_SLICEOBJECT * slice, IntVector v)
        __setitem__(IntVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _QuantLib.IntVector___setitem__(self, *args)

    def pop(self):
        r"""pop(IntVector self) -> std::vector< int >::value_type"""
        return _QuantLib.IntVector_pop(self)

    def append(self, x):
        r"""append(IntVector self, std::vector< int >::value_type const & x)"""
        return _QuantLib.IntVector_append(self, x)

    def empty(self):
        r"""empty(IntVector self) -> bool"""
        return _QuantLib.IntVector_empty(self)

    def size(self):
        r"""size(IntVector self) -> std::vector< int >::size_type"""
        return _QuantLib.IntVector_size(self)

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

    def begin(self):
        r"""begin(IntVector self) -> std::vector< int >::iterator"""
        return _QuantLib.IntVector_begin(self)

    def end(self):
        r"""end(IntVector self) -> std::vector< int >::iterator"""
        return _QuantLib.IntVector_end(self)

    def rbegin(self):
        r"""rbegin(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _QuantLib.IntVector_rbegin(self)

    def rend(self):
        r"""rend(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _QuantLib.IntVector_rend(self)

    def clear(self):
        r"""clear(IntVector self)"""
        return _QuantLib.IntVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(IntVector self) -> std::vector< int >::allocator_type"""
        return _QuantLib.IntVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IntVector self)"""
        return _QuantLib.IntVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _QuantLib.IntVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IntVector self) -> IntVector
        __init__(IntVector self, IntVector other) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        _QuantLib.IntVector_swiginit(self, _QuantLib.new_IntVector(*args))

    def push_back(self, x):
        r"""push_back(IntVector self, std::vector< int >::value_type const & x)"""
        return _QuantLib.IntVector_push_back(self, x)

    def front(self):
        r"""front(IntVector self) -> std::vector< int >::value_type const &"""
        return _QuantLib.IntVector_front(self)

    def back(self):
        r"""back(IntVector self) -> std::vector< int >::value_type const &"""
        return _QuantLib.IntVector_back(self)

    def assign(self, n, x):
        r"""assign(IntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _QuantLib.IntVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IntVector self, std::vector< int >::size_type new_size)
        resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _QuantLib.IntVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _QuantLib.IntVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(IntVector self, std::vector< int >::size_type n)"""
        return _QuantLib.IntVector_reserve(self, n)

    def capacity(self):
        r"""capacity(IntVector self) -> std::vector< int >::size_type"""
        return _QuantLib.IntVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_IntVector

# Register IntVector in _QuantLib:
_QuantLib.IntVector_swigregister(IntVector)
class UnsignedIntVector(object):
    r"""Proxy of C++ std::vector< unsigned int > class."""

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

    def iterator(self):
        r"""iterator(UnsignedIntVector self) -> SwigPyIterator"""
        return _QuantLib.UnsignedIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(UnsignedIntVector self) -> bool"""
        return _QuantLib.UnsignedIntVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(UnsignedIntVector self) -> bool"""
        return _QuantLib.UnsignedIntVector___bool__(self)

    def __len__(self):
        r"""__len__(UnsignedIntVector self) -> std::vector< unsigned int >::size_type"""
        return _QuantLib.UnsignedIntVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> UnsignedIntVector"""
        return _QuantLib.UnsignedIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)
        __setslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, UnsignedIntVector v)
        """
        return _QuantLib.UnsignedIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"""
        return _QuantLib.UnsignedIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i)
        __delitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.UnsignedIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice) -> UnsignedIntVector
        __getitem__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &
        """
        return _QuantLib.UnsignedIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice, UnsignedIntVector v)
        __setitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)
        """
        return _QuantLib.UnsignedIntVector___setitem__(self, *args)

    def pop(self):
        r"""pop(UnsignedIntVector self) -> std::vector< unsigned int >::value_type"""
        return _QuantLib.UnsignedIntVector_pop(self)

    def append(self, x):
        r"""append(UnsignedIntVector self, std::vector< unsigned int >::value_type const & x)"""
        return _QuantLib.UnsignedIntVector_append(self, x)

    def empty(self):
        r"""empty(UnsignedIntVector self) -> bool"""
        return _QuantLib.UnsignedIntVector_empty(self)

    def size(self):
        r"""size(UnsignedIntVector self) -> std::vector< unsigned int >::size_type"""
        return _QuantLib.UnsignedIntVector_size(self)

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

    def begin(self):
        r"""begin(UnsignedIntVector self) -> std::vector< unsigned int >::iterator"""
        return _QuantLib.UnsignedIntVector_begin(self)

    def end(self):
        r"""end(UnsignedIntVector self) -> std::vector< unsigned int >::iterator"""
        return _QuantLib.UnsignedIntVector_end(self)

    def rbegin(self):
        r"""rbegin(UnsignedIntVector self) -> std::vector< unsigned int >::reverse_iterator"""
        return _QuantLib.UnsignedIntVector_rbegin(self)

    def rend(self):
        r"""rend(UnsignedIntVector self) -> std::vector< unsigned int >::reverse_iterator"""
        return _QuantLib.UnsignedIntVector_rend(self)

    def clear(self):
        r"""clear(UnsignedIntVector self)"""
        return _QuantLib.UnsignedIntVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(UnsignedIntVector self) -> std::vector< unsigned int >::allocator_type"""
        return _QuantLib.UnsignedIntVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(UnsignedIntVector self)"""
        return _QuantLib.UnsignedIntVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(UnsignedIntVector self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator
        erase(UnsignedIntVector self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator
        """
        return _QuantLib.UnsignedIntVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(UnsignedIntVector self) -> UnsignedIntVector
        __init__(UnsignedIntVector self, UnsignedIntVector other) -> UnsignedIntVector
        __init__(UnsignedIntVector self, std::vector< unsigned int >::size_type size) -> UnsignedIntVector
        __init__(UnsignedIntVector self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> UnsignedIntVector
        """
        _QuantLib.UnsignedIntVector_swiginit(self, _QuantLib.new_UnsignedIntVector(*args))

    def push_back(self, x):
        r"""push_back(UnsignedIntVector self, std::vector< unsigned int >::value_type const & x)"""
        return _QuantLib.UnsignedIntVector_push_back(self, x)

    def front(self):
        r"""front(UnsignedIntVector self) -> std::vector< unsigned int >::value_type const &"""
        return _QuantLib.UnsignedIntVector_front(self)

    def back(self):
        r"""back(UnsignedIntVector self) -> std::vector< unsigned int >::value_type const &"""
        return _QuantLib.UnsignedIntVector_back(self)

    def assign(self, n, x):
        r"""assign(UnsignedIntVector self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"""
        return _QuantLib.UnsignedIntVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(UnsignedIntVector self, std::vector< unsigned int >::size_type new_size)
        resize(UnsignedIntVector self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)
        """
        return _QuantLib.UnsignedIntVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(UnsignedIntVector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator
        insert(UnsignedIntVector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)
        """
        return _QuantLib.UnsignedIntVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(UnsignedIntVector self, std::vector< unsigned int >::size_type n)"""
        return _QuantLib.UnsignedIntVector_reserve(self, n)

    def capacity(self):
        r"""capacity(UnsignedIntVector self) -> std::vector< unsigned int >::size_type"""
        return _QuantLib.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_UnsignedIntVector

# Register UnsignedIntVector in _QuantLib:
_QuantLib.UnsignedIntVector_swigregister(UnsignedIntVector)
class DoubleVector(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(DoubleVector self) -> SwigPyIterator"""
        return _QuantLib.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DoubleVector self) -> bool"""
        return _QuantLib.DoubleVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DoubleVector self) -> bool"""
        return _QuantLib.DoubleVector___bool__(self)

    def __len__(self):
        r"""__len__(DoubleVector self) -> std::vector< double >::size_type"""
        return _QuantLib.DoubleVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> DoubleVector"""
        return _QuantLib.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, DoubleVector v)
        """
        return _QuantLib.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _QuantLib.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DoubleVector self, std::vector< double >::difference_type i)
        __delitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice) -> DoubleVector
        __getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _QuantLib.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice, DoubleVector v)
        __setitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _QuantLib.DoubleVector___setitem__(self, *args)

    def pop(self):
        r"""pop(DoubleVector self) -> std::vector< double >::value_type"""
        return _QuantLib.DoubleVector_pop(self)

    def append(self, x):
        r"""append(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _QuantLib.DoubleVector_append(self, x)

    def empty(self):
        r"""empty(DoubleVector self) -> bool"""
        return _QuantLib.DoubleVector_empty(self)

    def size(self):
        r"""size(DoubleVector self) -> std::vector< double >::size_type"""
        return _QuantLib.DoubleVector_size(self)

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

    def begin(self):
        r"""begin(DoubleVector self) -> std::vector< double >::iterator"""
        return _QuantLib.DoubleVector_begin(self)

    def end(self):
        r"""end(DoubleVector self) -> std::vector< double >::iterator"""
        return _QuantLib.DoubleVector_end(self)

    def rbegin(self):
        r"""rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _QuantLib.DoubleVector_rbegin(self)

    def rend(self):
        r"""rend(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _QuantLib.DoubleVector_rend(self)

    def clear(self):
        r"""clear(DoubleVector self)"""
        return _QuantLib.DoubleVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"""
        return _QuantLib.DoubleVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DoubleVector self)"""
        return _QuantLib.DoubleVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DoubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(DoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _QuantLib.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DoubleVector self) -> DoubleVector
        __init__(DoubleVector self, DoubleVector other) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        _QuantLib.DoubleVector_swiginit(self, _QuantLib.new_DoubleVector(*args))

    def push_back(self, x):
        r"""push_back(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _QuantLib.DoubleVector_push_back(self, x)

    def front(self):
        r"""front(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _QuantLib.DoubleVector_front(self)

    def back(self):
        r"""back(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _QuantLib.DoubleVector_back(self)

    def assign(self, n, x):
        r"""assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _QuantLib.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DoubleVector self, std::vector< double >::size_type new_size)
        resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _QuantLib.DoubleVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _QuantLib.DoubleVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DoubleVector self, std::vector< double >::size_type n)"""
        return _QuantLib.DoubleVector_reserve(self, n)

    def capacity(self):
        r"""capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _QuantLib.DoubleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DoubleVector

# Register DoubleVector in _QuantLib:
_QuantLib.DoubleVector_swigregister(DoubleVector)
class StrVector(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(StrVector self) -> SwigPyIterator"""
        return _QuantLib.StrVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StrVector self) -> bool"""
        return _QuantLib.StrVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StrVector self) -> bool"""
        return _QuantLib.StrVector___bool__(self)

    def __len__(self):
        r"""__len__(StrVector self) -> std::vector< std::string >::size_type"""
        return _QuantLib.StrVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StrVector"""
        return _QuantLib.StrVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StrVector v)
        """
        return _QuantLib.StrVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _QuantLib.StrVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StrVector self, std::vector< std::string >::difference_type i)
        __delitem__(StrVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.StrVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StrVector self, SWIGPY_SLICEOBJECT * slice) -> StrVector
        __getitem__(StrVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _QuantLib.StrVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StrVector self, SWIGPY_SLICEOBJECT * slice, StrVector v)
        __setitem__(StrVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _QuantLib.StrVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StrVector self) -> std::vector< std::string >::value_type"""
        return _QuantLib.StrVector_pop(self)

    def append(self, x):
        r"""append(StrVector self, std::vector< std::string >::value_type const & x)"""
        return _QuantLib.StrVector_append(self, x)

    def empty(self):
        r"""empty(StrVector self) -> bool"""
        return _QuantLib.StrVector_empty(self)

    def size(self):
        r"""size(StrVector self) -> std::vector< std::string >::size_type"""
        return _QuantLib.StrVector_size(self)

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

    def begin(self):
        r"""begin(StrVector self) -> std::vector< std::string >::iterator"""
        return _QuantLib.StrVector_begin(self)

    def end(self):
        r"""end(StrVector self) -> std::vector< std::string >::iterator"""
        return _QuantLib.StrVector_end(self)

    def rbegin(self):
        r"""rbegin(StrVector self) -> std::vector< std::string >::reverse_iterator"""
        return _QuantLib.StrVector_rbegin(self)

    def rend(self):
        r"""rend(StrVector self) -> std::vector< std::string >::reverse_iterator"""
        return _QuantLib.StrVector_rend(self)

    def clear(self):
        r"""clear(StrVector self)"""
        return _QuantLib.StrVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StrVector self) -> std::vector< std::string >::allocator_type"""
        return _QuantLib.StrVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StrVector self)"""
        return _QuantLib.StrVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StrVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(StrVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _QuantLib.StrVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StrVector self) -> StrVector
        __init__(StrVector self, StrVector other) -> StrVector
        __init__(StrVector self, std::vector< std::string >::size_type size) -> StrVector
        __init__(StrVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StrVector
        """
        _QuantLib.StrVector_swiginit(self, _QuantLib.new_StrVector(*args))

    def push_back(self, x):
        r"""push_back(StrVector self, std::vector< std::string >::value_type const & x)"""
        return _QuantLib.StrVector_push_back(self, x)

    def front(self):
        r"""front(StrVector self) -> std::vector< std::string >::value_type const &"""
        return _QuantLib.StrVector_front(self)

    def back(self):
        r"""back(StrVector self) -> std::vector< std::string >::value_type const &"""
        return _QuantLib.StrVector_back(self)

    def assign(self, n, x):
        r"""assign(StrVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _QuantLib.StrVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StrVector self, std::vector< std::string >::size_type new_size)
        resize(StrVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _QuantLib.StrVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StrVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(StrVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _QuantLib.StrVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StrVector self, std::vector< std::string >::size_type n)"""
        return _QuantLib.StrVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StrVector self) -> std::vector< std::string >::size_type"""
        return _QuantLib.StrVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StrVector

# Register StrVector in _QuantLib:
_QuantLib.StrVector_swigregister(StrVector)
class BoolVector(object):
    r"""Proxy of C++ std::vector< bool > class."""

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

    def iterator(self):
        r"""iterator(BoolVector self) -> SwigPyIterator"""
        return _QuantLib.BoolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(BoolVector self) -> bool"""
        return _QuantLib.BoolVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(BoolVector self) -> bool"""
        return _QuantLib.BoolVector___bool__(self)

    def __len__(self):
        r"""__len__(BoolVector self) -> std::vector< bool >::size_type"""
        return _QuantLib.BoolVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j) -> BoolVector"""
        return _QuantLib.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)
        __setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j, BoolVector v)
        """
        return _QuantLib.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)"""
        return _QuantLib.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(BoolVector self, std::vector< bool >::difference_type i)
        __delitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice) -> BoolVector
        __getitem__(BoolVector self, std::vector< bool >::difference_type i) -> std::vector< bool >::value_type
        """
        return _QuantLib.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice, BoolVector v)
        __setitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::value_type x)
        """
        return _QuantLib.BoolVector___setitem__(self, *args)

    def pop(self):
        r"""pop(BoolVector self) -> std::vector< bool >::value_type"""
        return _QuantLib.BoolVector_pop(self)

    def append(self, x):
        r"""append(BoolVector self, std::vector< bool >::value_type x)"""
        return _QuantLib.BoolVector_append(self, x)

    def empty(self):
        r"""empty(BoolVector self) -> bool"""
        return _QuantLib.BoolVector_empty(self)

    def size(self):
        r"""size(BoolVector self) -> std::vector< bool >::size_type"""
        return _QuantLib.BoolVector_size(self)

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

    def begin(self):
        r"""begin(BoolVector self) -> std::vector< bool >::iterator"""
        return _QuantLib.BoolVector_begin(self)

    def end(self):
        r"""end(BoolVector self) -> std::vector< bool >::iterator"""
        return _QuantLib.BoolVector_end(self)

    def rbegin(self):
        r"""rbegin(BoolVector self) -> std::vector< bool >::reverse_iterator"""
        return _QuantLib.BoolVector_rbegin(self)

    def rend(self):
        r"""rend(BoolVector self) -> std::vector< bool >::reverse_iterator"""
        return _QuantLib.BoolVector_rend(self)

    def clear(self):
        r"""clear(BoolVector self)"""
        return _QuantLib.BoolVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(BoolVector self) -> std::vector< bool >::allocator_type"""
        return _QuantLib.BoolVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(BoolVector self)"""
        return _QuantLib.BoolVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(BoolVector self, std::vector< bool >::iterator pos) -> std::vector< bool >::iterator
        erase(BoolVector self, std::vector< bool >::iterator first, std::vector< bool >::iterator last) -> std::vector< bool >::iterator
        """
        return _QuantLib.BoolVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(BoolVector self) -> BoolVector
        __init__(BoolVector self, BoolVector other) -> BoolVector
        __init__(BoolVector self, std::vector< bool >::size_type size) -> BoolVector
        __init__(BoolVector self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> BoolVector
        """
        _QuantLib.BoolVector_swiginit(self, _QuantLib.new_BoolVector(*args))

    def push_back(self, x):
        r"""push_back(BoolVector self, std::vector< bool >::value_type x)"""
        return _QuantLib.BoolVector_push_back(self, x)

    def front(self):
        r"""front(BoolVector self) -> std::vector< bool >::value_type"""
        return _QuantLib.BoolVector_front(self)

    def back(self):
        r"""back(BoolVector self) -> std::vector< bool >::value_type"""
        return _QuantLib.BoolVector_back(self)

    def assign(self, n, x):
        r"""assign(BoolVector self, std::vector< bool >::size_type n, std::vector< bool >::value_type x)"""
        return _QuantLib.BoolVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(BoolVector self, std::vector< bool >::size_type new_size)
        resize(BoolVector self, std::vector< bool >::size_type new_size, std::vector< bool >::value_type x)
        """
        return _QuantLib.BoolVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(BoolVector self, std::vector< bool >::iterator pos, std::vector< bool >::value_type x) -> std::vector< bool >::iterator
        insert(BoolVector self, std::vector< bool >::iterator pos, std::vector< bool >::size_type n, std::vector< bool >::value_type x)
        """
        return _QuantLib.BoolVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(BoolVector self, std::vector< bool >::size_type n)"""
        return _QuantLib.BoolVector_reserve(self, n)

    def capacity(self):
        r"""capacity(BoolVector self) -> std::vector< bool >::size_type"""
        return _QuantLib.BoolVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_BoolVector

# Register BoolVector in _QuantLib:
_QuantLib.BoolVector_swigregister(BoolVector)
class DoublePair(object):
    r"""Proxy of C++ std::pair< double,double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DoublePair self) -> DoublePair
        __init__(DoublePair self, double first, double second) -> DoublePair
        __init__(DoublePair self, DoublePair other) -> DoublePair
        """
        _QuantLib.DoublePair_swiginit(self, _QuantLib.new_DoublePair(*args))
    first = property(_QuantLib.DoublePair_first_get, _QuantLib.DoublePair_first_set, doc=r"""first : double""")
    second = property(_QuantLib.DoublePair_second_get, _QuantLib.DoublePair_second_set, doc=r"""second : double""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _QuantLib.delete_DoublePair

# Register DoublePair in _QuantLib:
_QuantLib.DoublePair_swigregister(DoublePair)
class DoublePairVector(object):
    r"""Proxy of C++ std::vector< std::pair< double,double > > class."""

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

    def iterator(self):
        r"""iterator(DoublePairVector self) -> SwigPyIterator"""
        return _QuantLib.DoublePairVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DoublePairVector self) -> bool"""
        return _QuantLib.DoublePairVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DoublePairVector self) -> bool"""
        return _QuantLib.DoublePairVector___bool__(self)

    def __len__(self):
        r"""__len__(DoublePairVector self) -> std::vector< std::pair< double,double > >::size_type"""
        return _QuantLib.DoublePairVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j) -> DoublePairVector"""
        return _QuantLib.DoublePairVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)
        __setslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j, DoublePairVector v)
        """
        return _QuantLib.DoublePairVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"""
        return _QuantLib.DoublePairVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i)
        __delitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.DoublePairVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice) -> DoublePairVector
        __getitem__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i) -> DoublePair
        """
        return _QuantLib.DoublePairVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice, DoublePairVector v)
        __setitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, DoublePair x)
        """
        return _QuantLib.DoublePairVector___setitem__(self, *args)

    def pop(self):
        r"""pop(DoublePairVector self) -> DoublePair"""
        return _QuantLib.DoublePairVector_pop(self)

    def append(self, x):
        r"""append(DoublePairVector self, DoublePair x)"""
        return _QuantLib.DoublePairVector_append(self, x)

    def empty(self):
        r"""empty(DoublePairVector self) -> bool"""
        return _QuantLib.DoublePairVector_empty(self)

    def size(self):
        r"""size(DoublePairVector self) -> std::vector< std::pair< double,double > >::size_type"""
        return _QuantLib.DoublePairVector_size(self)

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

    def begin(self):
        r"""begin(DoublePairVector self) -> std::vector< std::pair< double,double > >::iterator"""
        return _QuantLib.DoublePairVector_begin(self)

    def end(self):
        r"""end(DoublePairVector self) -> std::vector< std::pair< double,double > >::iterator"""
        return _QuantLib.DoublePairVector_end(self)

    def rbegin(self):
        r"""rbegin(DoublePairVector self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
        return _QuantLib.DoublePairVector_rbegin(self)

    def rend(self):
        r"""rend(DoublePairVector self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
        return _QuantLib.DoublePairVector_rend(self)

    def clear(self):
        r"""clear(DoublePairVector self)"""
        return _QuantLib.DoublePairVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(DoublePairVector self) -> std::vector< std::pair< double,double > >::allocator_type"""
        return _QuantLib.DoublePairVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DoublePairVector self)"""
        return _QuantLib.DoublePairVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DoublePairVector self, std::vector< std::pair< double,double > >::iterator pos) -> std::vector< std::pair< double,double > >::iterator
        erase(DoublePairVector self, std::vector< std::pair< double,double > >::iterator first, std::vector< std::pair< double,double > >::iterator last) -> std::vector< std::pair< double,double > >::iterator
        """
        return _QuantLib.DoublePairVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DoublePairVector self) -> DoublePairVector
        __init__(DoublePairVector self, DoublePairVector other) -> DoublePairVector
        __init__(DoublePairVector self, std::vector< std::pair< double,double > >::size_type size) -> DoublePairVector
        __init__(DoublePairVector self, std::vector< std::pair< double,double > >::size_type size, DoublePair value) -> DoublePairVector
        """
        _QuantLib.DoublePairVector_swiginit(self, _QuantLib.new_DoublePairVector(*args))

    def push_back(self, x):
        r"""push_back(DoublePairVector self, DoublePair x)"""
        return _QuantLib.DoublePairVector_push_back(self, x)

    def front(self):
        r"""front(DoublePairVector self) -> DoublePair"""
        return _QuantLib.DoublePairVector_front(self)

    def back(self):
        r"""back(DoublePairVector self) -> DoublePair"""
        return _QuantLib.DoublePairVector_back(self)

    def assign(self, n, x):
        r"""assign(DoublePairVector self, std::vector< std::pair< double,double > >::size_type n, DoublePair x)"""
        return _QuantLib.DoublePairVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DoublePairVector self, std::vector< std::pair< double,double > >::size_type new_size)
        resize(DoublePairVector self, std::vector< std::pair< double,double > >::size_type new_size, DoublePair x)
        """
        return _QuantLib.DoublePairVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DoublePairVector self, std::vector< std::pair< double,double > >::iterator pos, DoublePair x) -> std::vector< std::pair< double,double > >::iterator
        insert(DoublePairVector self, std::vector< std::pair< double,double > >::iterator pos, std::vector< std::pair< double,double > >::size_type n, DoublePair x)
        """
        return _QuantLib.DoublePairVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DoublePairVector self, std::vector< std::pair< double,double > >::size_type n)"""
        return _QuantLib.DoublePairVector_reserve(self, n)

    def capacity(self):
        r"""capacity(DoublePairVector self) -> std::vector< std::pair< double,double > >::size_type"""
        return _QuantLib.DoublePairVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DoublePairVector

# Register DoublePairVector in _QuantLib:
_QuantLib.DoublePairVector_swigregister(DoublePairVector)
class PairDoubleVector(object):
    r"""Proxy of C++ std::pair< std::vector< double >,std::vector< double > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PairDoubleVector self) -> PairDoubleVector
        __init__(PairDoubleVector self, DoubleVector first, DoubleVector second) -> PairDoubleVector
        __init__(PairDoubleVector self, PairDoubleVector other) -> PairDoubleVector
        """
        _QuantLib.PairDoubleVector_swiginit(self, _QuantLib.new_PairDoubleVector(*args))
    first = property(_QuantLib.PairDoubleVector_first_get, _QuantLib.PairDoubleVector_first_set, doc=r"""first : std::vector<(double,std::allocator<(double)>)>""")
    second = property(_QuantLib.PairDoubleVector_second_get, _QuantLib.PairDoubleVector_second_set, doc=r"""second : std::vector<(double,std::allocator<(double)>)>""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _QuantLib.delete_PairDoubleVector

# Register PairDoubleVector in _QuantLib:
_QuantLib.PairDoubleVector_swigregister(PairDoubleVector)
class UnsignedIntPair(object):
    r"""Proxy of C++ std::pair< unsigned int,unsigned int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnsignedIntPair self) -> UnsignedIntPair
        __init__(UnsignedIntPair self, unsigned int first, unsigned int second) -> UnsignedIntPair
        __init__(UnsignedIntPair self, UnsignedIntPair other) -> UnsignedIntPair
        """
        _QuantLib.UnsignedIntPair_swiginit(self, _QuantLib.new_UnsignedIntPair(*args))
    first = property(_QuantLib.UnsignedIntPair_first_get, _QuantLib.UnsignedIntPair_first_set, doc=r"""first : unsigned int""")
    second = property(_QuantLib.UnsignedIntPair_second_get, _QuantLib.UnsignedIntPair_second_set, doc=r"""second : unsigned int""")
    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_UnsignedIntPair

# Register UnsignedIntPair in _QuantLib:
_QuantLib.UnsignedIntPair_swigregister(UnsignedIntPair)
class UnsignedIntPairVector(object):
    r"""Proxy of C++ std::vector< std::pair< unsigned int,unsigned int > > class."""

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

    def iterator(self):
        r"""iterator(UnsignedIntPairVector self) -> SwigPyIterator"""
        return _QuantLib.UnsignedIntPairVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(UnsignedIntPairVector self) -> bool"""
        return _QuantLib.UnsignedIntPairVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(UnsignedIntPairVector self) -> bool"""
        return _QuantLib.UnsignedIntPairVector___bool__(self)

    def __len__(self):
        r"""__len__(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::size_type"""
        return _QuantLib.UnsignedIntPairVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j) -> UnsignedIntPairVector"""
        return _QuantLib.UnsignedIntPairVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j)
        __setslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j, UnsignedIntPairVector v)
        """
        return _QuantLib.UnsignedIntPairVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j)"""
        return _QuantLib.UnsignedIntPairVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i)
        __delitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.UnsignedIntPairVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice) -> UnsignedIntPairVector
        __getitem__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i) -> UnsignedIntPair
        """
        return _QuantLib.UnsignedIntPairVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice, UnsignedIntPairVector v)
        __setitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, UnsignedIntPair x)
        """
        return _QuantLib.UnsignedIntPairVector___setitem__(self, *args)

    def pop(self):
        r"""pop(UnsignedIntPairVector self) -> UnsignedIntPair"""
        return _QuantLib.UnsignedIntPairVector_pop(self)

    def append(self, x):
        r"""append(UnsignedIntPairVector self, UnsignedIntPair x)"""
        return _QuantLib.UnsignedIntPairVector_append(self, x)

    def empty(self):
        r"""empty(UnsignedIntPairVector self) -> bool"""
        return _QuantLib.UnsignedIntPairVector_empty(self)

    def size(self):
        r"""size(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::size_type"""
        return _QuantLib.UnsignedIntPairVector_size(self)

    def swap(self, v):
        r"""swap(UnsignedIntPairVector self, UnsignedIntPairVector v)"""
        return _QuantLib.UnsignedIntPairVector_swap(self, v)

    def begin(self):
        r"""begin(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator"""
        return _QuantLib.UnsignedIntPairVector_begin(self)

    def end(self):
        r"""end(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator"""
        return _QuantLib.UnsignedIntPairVector_end(self)

    def rbegin(self):
        r"""rbegin(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator"""
        return _QuantLib.UnsignedIntPairVector_rbegin(self)

    def rend(self):
        r"""rend(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator"""
        return _QuantLib.UnsignedIntPairVector_rend(self)

    def clear(self):
        r"""clear(UnsignedIntPairVector self)"""
        return _QuantLib.UnsignedIntPairVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::allocator_type"""
        return _QuantLib.UnsignedIntPairVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(UnsignedIntPairVector self)"""
        return _QuantLib.UnsignedIntPairVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator pos) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator
        erase(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator first, std::vector< std::pair< unsigned int,unsigned int > >::iterator last) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator
        """
        return _QuantLib.UnsignedIntPairVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(UnsignedIntPairVector self) -> UnsignedIntPairVector
        __init__(UnsignedIntPairVector self, UnsignedIntPairVector other) -> UnsignedIntPairVector
        __init__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type size) -> UnsignedIntPairVector
        __init__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type size, UnsignedIntPair value) -> UnsignedIntPairVector
        """
        _QuantLib.UnsignedIntPairVector_swiginit(self, _QuantLib.new_UnsignedIntPairVector(*args))

    def push_back(self, x):
        r"""push_back(UnsignedIntPairVector self, UnsignedIntPair x)"""
        return _QuantLib.UnsignedIntPairVector_push_back(self, x)

    def front(self):
        r"""front(UnsignedIntPairVector self) -> UnsignedIntPair"""
        return _QuantLib.UnsignedIntPairVector_front(self)

    def back(self):
        r"""back(UnsignedIntPairVector self) -> UnsignedIntPair"""
        return _QuantLib.UnsignedIntPairVector_back(self)

    def assign(self, n, x):
        r"""assign(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type n, UnsignedIntPair x)"""
        return _QuantLib.UnsignedIntPairVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type new_size)
        resize(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type new_size, UnsignedIntPair x)
        """
        return _QuantLib.UnsignedIntPairVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator pos, UnsignedIntPair x) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator
        insert(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator pos, std::vector< std::pair< unsigned int,unsigned int > >::size_type n, UnsignedIntPair x)
        """
        return _QuantLib.UnsignedIntPairVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type n)"""
        return _QuantLib.UnsignedIntPairVector_reserve(self, n)

    def capacity(self):
        r"""capacity(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::size_type"""
        return _QuantLib.UnsignedIntPairVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_UnsignedIntPairVector

# Register UnsignedIntPairVector in _QuantLib:
_QuantLib.UnsignedIntPairVector_swigregister(UnsignedIntPairVector)
class NodePair(object):
    r"""Proxy of C++ std::pair< Date,double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(NodePair self) -> NodePair
        __init__(NodePair self, Date first, double second) -> NodePair
        __init__(NodePair self, NodePair other) -> NodePair
        """
        _QuantLib.NodePair_swiginit(self, _QuantLib.new_NodePair(*args))
    first = property(_QuantLib.NodePair_first_get, _QuantLib.NodePair_first_set, doc=r"""first : Date""")
    second = property(_QuantLib.NodePair_second_get, _QuantLib.NodePair_second_set, doc=r"""second : double""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _QuantLib.delete_NodePair

# Register NodePair in _QuantLib:
_QuantLib.NodePair_swigregister(NodePair)
class NodeVector(object):
    r"""Proxy of C++ std::vector< std::pair< Date,double > > class."""

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

    def iterator(self):
        r"""iterator(NodeVector self) -> SwigPyIterator"""
        return _QuantLib.NodeVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(NodeVector self) -> bool"""
        return _QuantLib.NodeVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(NodeVector self) -> bool"""
        return _QuantLib.NodeVector___bool__(self)

    def __len__(self):
        r"""__len__(NodeVector self) -> std::vector< std::pair< Date,double > >::size_type"""
        return _QuantLib.NodeVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j) -> NodeVector"""
        return _QuantLib.NodeVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j)
        __setslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j, NodeVector v)
        """
        return _QuantLib.NodeVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j)"""
        return _QuantLib.NodeVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i)
        __delitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.NodeVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice) -> NodeVector
        __getitem__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i) -> NodePair
        """
        return _QuantLib.NodeVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice, NodeVector v)
        __setitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, NodePair x)
        """
        return _QuantLib.NodeVector___setitem__(self, *args)

    def pop(self):
        r"""pop(NodeVector self) -> NodePair"""
        return _QuantLib.NodeVector_pop(self)

    def append(self, x):
        r"""append(NodeVector self, NodePair x)"""
        return _QuantLib.NodeVector_append(self, x)

    def empty(self):
        r"""empty(NodeVector self) -> bool"""
        return _QuantLib.NodeVector_empty(self)

    def size(self):
        r"""size(NodeVector self) -> std::vector< std::pair< Date,double > >::size_type"""
        return _QuantLib.NodeVector_size(self)

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

    def begin(self):
        r"""begin(NodeVector self) -> std::vector< std::pair< Date,double > >::iterator"""
        return _QuantLib.NodeVector_begin(self)

    def end(self):
        r"""end(NodeVector self) -> std::vector< std::pair< Date,double > >::iterator"""
        return _QuantLib.NodeVector_end(self)

    def rbegin(self):
        r"""rbegin(NodeVector self) -> std::vector< std::pair< Date,double > >::reverse_iterator"""
        return _QuantLib.NodeVector_rbegin(self)

    def rend(self):
        r"""rend(NodeVector self) -> std::vector< std::pair< Date,double > >::reverse_iterator"""
        return _QuantLib.NodeVector_rend(self)

    def clear(self):
        r"""clear(NodeVector self)"""
        return _QuantLib.NodeVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(NodeVector self) -> std::vector< std::pair< Date,double > >::allocator_type"""
        return _QuantLib.NodeVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(NodeVector self)"""
        return _QuantLib.NodeVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(NodeVector self, std::vector< std::pair< Date,double > >::iterator pos) -> std::vector< std::pair< Date,double > >::iterator
        erase(NodeVector self, std::vector< std::pair< Date,double > >::iterator first, std::vector< std::pair< Date,double > >::iterator last) -> std::vector< std::pair< Date,double > >::iterator
        """
        return _QuantLib.NodeVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(NodeVector self) -> NodeVector
        __init__(NodeVector self, NodeVector other) -> NodeVector
        __init__(NodeVector self, std::vector< std::pair< Date,double > >::size_type size) -> NodeVector
        __init__(NodeVector self, std::vector< std::pair< Date,double > >::size_type size, NodePair value) -> NodeVector
        """
        _QuantLib.NodeVector_swiginit(self, _QuantLib.new_NodeVector(*args))

    def push_back(self, x):
        r"""push_back(NodeVector self, NodePair x)"""
        return _QuantLib.NodeVector_push_back(self, x)

    def front(self):
        r"""front(NodeVector self) -> NodePair"""
        return _QuantLib.NodeVector_front(self)

    def back(self):
        r"""back(NodeVector self) -> NodePair"""
        return _QuantLib.NodeVector_back(self)

    def assign(self, n, x):
        r"""assign(NodeVector self, std::vector< std::pair< Date,double > >::size_type n, NodePair x)"""
        return _QuantLib.NodeVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(NodeVector self, std::vector< std::pair< Date,double > >::size_type new_size)
        resize(NodeVector self, std::vector< std::pair< Date,double > >::size_type new_size, NodePair x)
        """
        return _QuantLib.NodeVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(NodeVector self, std::vector< std::pair< Date,double > >::iterator pos, NodePair x) -> std::vector< std::pair< Date,double > >::iterator
        insert(NodeVector self, std::vector< std::pair< Date,double > >::iterator pos, std::vector< std::pair< Date,double > >::size_type n, NodePair x)
        """
        return _QuantLib.NodeVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(NodeVector self, std::vector< std::pair< Date,double > >::size_type n)"""
        return _QuantLib.NodeVector_reserve(self, n)

    def capacity(self):
        r"""capacity(NodeVector self) -> std::vector< std::pair< Date,double > >::size_type"""
        return _QuantLib.NodeVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_NodeVector

# Register NodeVector in _QuantLib:
_QuantLib.NodeVector_swigregister(NodeVector)
class Exercise(object):
    r"""Proxy of C++ Exercise class."""

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

    def __init__(self, type):
        r"""__init__(Exercise self, Exercise::Type type) -> Exercise"""
        _QuantLib.Exercise_swiginit(self, _QuantLib.new_Exercise(type))

    def type(self):
        r"""type(Exercise self) -> Exercise::Type"""
        return _QuantLib.Exercise_type(self)

    def date(self, index):
        r"""date(Exercise self, Size index) -> Date"""
        return _QuantLib.Exercise_date(self, index)

    def dateAt(self, index):
        r"""dateAt(Exercise self, Size index) -> Date"""
        return _QuantLib.Exercise_dateAt(self, index)

    def dates(self):
        r"""dates(Exercise self) -> DateVector"""
        return _QuantLib.Exercise_dates(self)

    def lastDate(self):
        r"""lastDate(Exercise self) -> Date"""
        return _QuantLib.Exercise_lastDate(self)
    __swig_destroy__ = _QuantLib.delete_Exercise

# Register Exercise in _QuantLib:
_QuantLib.Exercise_swigregister(Exercise)
class EuropeanExercise(Exercise):
    r"""Proxy of C++ EuropeanExercise class."""

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

    def __init__(self, date):
        r"""__init__(EuropeanExercise self, Date date) -> EuropeanExercise"""
        _QuantLib.EuropeanExercise_swiginit(self, _QuantLib.new_EuropeanExercise(date))
    __swig_destroy__ = _QuantLib.delete_EuropeanExercise

# Register EuropeanExercise in _QuantLib:
_QuantLib.EuropeanExercise_swigregister(EuropeanExercise)
class AmericanExercise(Exercise):
    r"""Proxy of C++ AmericanExercise class."""

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

    def __init__(self, earliestDate, latestDate, payoffAtExpiry=False):
        r"""__init__(AmericanExercise self, Date earliestDate, Date latestDate, bool payoffAtExpiry=False) -> AmericanExercise"""
        _QuantLib.AmericanExercise_swiginit(self, _QuantLib.new_AmericanExercise(earliestDate, latestDate, payoffAtExpiry))
    __swig_destroy__ = _QuantLib.delete_AmericanExercise

# Register AmericanExercise in _QuantLib:
_QuantLib.AmericanExercise_swigregister(AmericanExercise)
class BermudanExercise(Exercise):
    r"""Proxy of C++ BermudanExercise class."""

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

    def __init__(self, dates, payoffAtExpiry=False):
        r"""__init__(BermudanExercise self, DateVector dates, bool payoffAtExpiry=False) -> BermudanExercise"""
        _QuantLib.BermudanExercise_swiginit(self, _QuantLib.new_BermudanExercise(dates, payoffAtExpiry))
    __swig_destroy__ = _QuantLib.delete_BermudanExercise

# Register BermudanExercise in _QuantLib:
_QuantLib.BermudanExercise_swigregister(BermudanExercise)
class RebatedExercise(Exercise):
    r"""Proxy of C++ RebatedExercise class."""

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

    def __init__(self, *args):
        r"""__init__(RebatedExercise self, Exercise exercise, DoubleVector rebates, Natural rebateSettlementDays=0, Calendar rebatePaymentCalendar=NullCalendar(), BusinessDayConvention const rebatePaymentConvention=Following) -> RebatedExercise"""
        _QuantLib.RebatedExercise_swiginit(self, _QuantLib.new_RebatedExercise(*args))
    __swig_destroy__ = _QuantLib.delete_RebatedExercise

# Register RebatedExercise in _QuantLib:
_QuantLib.RebatedExercise_swigregister(RebatedExercise)
class SwingExercise(Exercise):
    r"""Proxy of C++ SwingExercise class."""

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

    def __init__(self, dates):
        r"""__init__(SwingExercise self, DateVector dates) -> SwingExercise"""
        _QuantLib.SwingExercise_swiginit(self, _QuantLib.new_SwingExercise(dates))
    __swig_destroy__ = _QuantLib.delete_SwingExercise

# Register SwingExercise in _QuantLib:
_QuantLib.SwingExercise_swigregister(SwingExercise)
class Observable(object):
    r"""Proxy of C++ Observable class."""

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

    def __init__(self):
        r"""__init__(Observable self) -> Observable"""
        _QuantLib.Observable_swiginit(self, _QuantLib.new_Observable())
    __swig_destroy__ = _QuantLib.delete_Observable

# Register Observable in _QuantLib:
_QuantLib.Observable_swigregister(Observable)
class Observer(object):
    r"""Proxy of C++ PyObserver class."""

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

    def __init__(self, callback):
        r"""__init__(Observer self, PyObject * callback) -> Observer"""
        _QuantLib.Observer_swiginit(self, _QuantLib.new_Observer(callback))

    def _registerWith(self, arg2):
        r"""_registerWith(Observer self, ext::shared_ptr< Observable > const & arg2)"""
        return _QuantLib.Observer__registerWith(self, arg2)

    def _unregisterWith(self, arg2):
        r"""_unregisterWith(Observer self, ext::shared_ptr< Observable > const & arg2)"""
        return _QuantLib.Observer__unregisterWith(self, arg2)

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

    __swig_destroy__ = _QuantLib.delete_Observer

# Register Observer in _QuantLib:
_QuantLib.Observer_swigregister(Observer)
class Array(object):
    r"""Proxy of C++ Array class."""

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

    def __init__(self, *args):
        r"""
        __init__(Array self) -> Array
        __init__(Array self, Size n, Real fill=0.0) -> Array
        __init__(Array self, Array arg2) -> Array
        """
        _QuantLib.Array_swiginit(self, _QuantLib.new_Array(*args))

    def __len__(self):
        r"""__len__(Array self) -> Size"""
        return _QuantLib.Array___len__(self)

    def __str__(self):
        r"""__str__(Array self) -> std::string"""
        return _QuantLib.Array___str__(self)

    def __add__(self, a):
        r"""__add__(Array self, Array a) -> Array"""
        return _QuantLib.Array___add__(self, a)

    def __sub__(self, a):
        r"""__sub__(Array self, Array a) -> Array"""
        return _QuantLib.Array___sub__(self, a)

    def __mul__(self, *args):
        r"""
        __mul__(Array self, Real a) -> Array
        __mul__(Array self, Array a) -> Real
        __mul__(Array self, Matrix a) -> Array
        """
        return _QuantLib.Array___mul__(self, *args)

    def __div__(self, a):
        r"""__div__(Array self, Real a) -> Array"""
        return _QuantLib.Array___div__(self, a)

    def __rmul__(self, a):
        r"""__rmul__(Array self, Real a) -> Array"""
        return _QuantLib.Array___rmul__(self, a)

    def __getslice__(self, i, j):
        r"""__getslice__(Array self, Integer i, Integer j) -> Array"""
        return _QuantLib.Array___getslice__(self, i, j)

    def __setslice__(self, i, j, rhs):
        r"""__setslice__(Array self, Integer i, Integer j, Array rhs)"""
        return _QuantLib.Array___setslice__(self, i, j, rhs)

    def __nonzero__(self):
        r"""__nonzero__(Array self) -> bool"""
        return _QuantLib.Array___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Array self) -> bool"""
        return _QuantLib.Array___bool__(self)

    def __getitem__(self, i):
        r"""__getitem__(Array self, Integer i) -> Real"""
        return _QuantLib.Array___getitem__(self, i)

    def __setitem__(self, i, x):
        r"""__setitem__(Array self, Integer i, Real x)"""
        return _QuantLib.Array___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_Array

# Register Array in _QuantLib:
_QuantLib.Array_swigregister(Array)
class DefaultLexicographicalViewColumn(object):
    r"""Proxy of C++ DefaultLexicographicalViewColumn class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __getitem__(self, i):
        r"""__getitem__(DefaultLexicographicalViewColumn self, Size i) -> Real"""
        return _QuantLib.DefaultLexicographicalViewColumn___getitem__(self, i)

    def __setitem__(self, i, x):
        r"""__setitem__(DefaultLexicographicalViewColumn self, Size i, Real x)"""
        return _QuantLib.DefaultLexicographicalViewColumn___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_DefaultLexicographicalViewColumn

# Register DefaultLexicographicalViewColumn in _QuantLib:
_QuantLib.DefaultLexicographicalViewColumn_swigregister(DefaultLexicographicalViewColumn)
class LexicographicalView(object):
    r"""Proxy of C++ DefaultLexicographicalView class."""

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

    def xSize(self):
        r"""xSize(LexicographicalView self) -> Size"""
        return _QuantLib.LexicographicalView_xSize(self)

    def ySize(self):
        r"""ySize(LexicographicalView self) -> Size"""
        return _QuantLib.LexicographicalView_ySize(self)

    def __init__(self, a, xSize):
        r"""__init__(LexicographicalView self, Array a, Size xSize) -> LexicographicalView"""
        _QuantLib.LexicographicalView_swiginit(self, _QuantLib.new_LexicographicalView(a, xSize))

    def __str__(self):
        r"""__str__(LexicographicalView self) -> std::string"""
        return _QuantLib.LexicographicalView___str__(self)

    def __getitem__(self, i):
        r"""__getitem__(LexicographicalView self, Size i) -> DefaultLexicographicalViewColumn"""
        return _QuantLib.LexicographicalView___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_LexicographicalView

# Register LexicographicalView in _QuantLib:
_QuantLib.LexicographicalView_swigregister(LexicographicalView)
class MatrixRow(object):
    r"""Proxy of C++ MatrixRow class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __getitem__(self, i):
        r"""__getitem__(MatrixRow self, Integer i) -> Real"""
        return _QuantLib.MatrixRow___getitem__(self, i)

    def __setitem__(self, i, x):
        r"""__setitem__(MatrixRow self, Integer i, Real x)"""
        return _QuantLib.MatrixRow___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_MatrixRow

# Register MatrixRow in _QuantLib:
_QuantLib.MatrixRow_swigregister(MatrixRow)
class Matrix(object):
    r"""Proxy of C++ Matrix class."""

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

    def __init__(self, *args):
        r"""
        __init__(Matrix self) -> Matrix
        __init__(Matrix self, Size rows, Size columns, Real fill=0.0) -> Matrix
        __init__(Matrix self, Matrix arg2) -> Matrix
        """
        _QuantLib.Matrix_swiginit(self, _QuantLib.new_Matrix(*args))

    def rows(self):
        r"""rows(Matrix self) -> Size"""
        return _QuantLib.Matrix_rows(self)

    def columns(self):
        r"""columns(Matrix self) -> Size"""
        return _QuantLib.Matrix_columns(self)

    def __str__(self):
        r"""__str__(Matrix self) -> std::string"""
        return _QuantLib.Matrix___str__(self)

    def __add__(self, m):
        r"""__add__(Matrix self, Matrix m) -> Matrix"""
        return _QuantLib.Matrix___add__(self, m)

    def __sub__(self, m):
        r"""__sub__(Matrix self, Matrix m) -> Matrix"""
        return _QuantLib.Matrix___sub__(self, m)

    def __mul__(self, *args):
        r"""
        __mul__(Matrix self, Real x) -> Matrix
        __mul__(Matrix self, Array x) -> Array
        __mul__(Matrix self, Matrix x) -> Matrix
        """
        return _QuantLib.Matrix___mul__(self, *args)

    def __div__(self, x):
        r"""__div__(Matrix self, Real x) -> Matrix"""
        return _QuantLib.Matrix___div__(self, x)

    def __getitem__(self, i):
        r"""__getitem__(Matrix self, Integer i) -> MatrixRow"""
        return _QuantLib.Matrix___getitem__(self, i)

    def __rmul__(self, *args):
        r"""
        __rmul__(Matrix self, Real x) -> Matrix
        __rmul__(Matrix self, Array x) -> Array
        __rmul__(Matrix self, Matrix x) -> Matrix
        """
        return _QuantLib.Matrix___rmul__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Matrix

# Register Matrix in _QuantLib:
_QuantLib.Matrix_swigregister(Matrix)
class SalvagingAlgorithm(object):
    r"""Proxy of C++ SalvagingAlgorithm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoAlgorithm = _QuantLib.SalvagingAlgorithm_NoAlgorithm
    
    Spectral = _QuantLib.SalvagingAlgorithm_Spectral
    

    def __init__(self):
        r"""__init__(SalvagingAlgorithm self) -> SalvagingAlgorithm"""
        _QuantLib.SalvagingAlgorithm_swiginit(self, _QuantLib.new_SalvagingAlgorithm())
    __swig_destroy__ = _QuantLib.delete_SalvagingAlgorithm

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

def inverse(m):
    r"""inverse(Matrix m) -> Matrix"""
    return _QuantLib.inverse(m)

def transpose(m):
    r"""transpose(Matrix m) -> Matrix"""
    return _QuantLib.transpose(m)

def outerProduct(v1, v2):
    r"""outerProduct(Array v1, Array v2) -> Matrix"""
    return _QuantLib.outerProduct(v1, v2)

def pseudoSqrt(m, a):
    r"""pseudoSqrt(Matrix m, SalvagingAlgorithm::Type a) -> Matrix"""
    return _QuantLib.pseudoSqrt(m, a)
class SVD(object):
    r"""Proxy of C++ SVD class."""

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

    def __init__(self, arg2):
        r"""__init__(SVD self, Matrix arg2) -> SVD"""
        _QuantLib.SVD_swiginit(self, _QuantLib.new_SVD(arg2))

    def U(self):
        r"""U(SVD self) -> Matrix"""
        return _QuantLib.SVD_U(self)

    def V(self):
        r"""V(SVD self) -> Matrix"""
        return _QuantLib.SVD_V(self)

    def S(self):
        r"""S(SVD self) -> Matrix"""
        return _QuantLib.SVD_S(self)

    def singularValues(self):
        r"""singularValues(SVD self) -> Array"""
        return _QuantLib.SVD_singularValues(self)
    __swig_destroy__ = _QuantLib.delete_SVD

# Register SVD in _QuantLib:
_QuantLib.SVD_swigregister(SVD)
class MatrixMultiplicationProxy(object):
    r"""Proxy of C++ MatrixMultiplicationProxy class."""

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

    def __init__(self, matrixMult):
        r"""__init__(MatrixMultiplicationProxy self, PyObject * matrixMult) -> MatrixMultiplicationProxy"""
        _QuantLib.MatrixMultiplicationProxy_swiginit(self, _QuantLib.new_MatrixMultiplicationProxy(matrixMult))

    def __call__(self, x):
        r"""__call__(MatrixMultiplicationProxy self, Array x) -> Array"""
        return _QuantLib.MatrixMultiplicationProxy___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_MatrixMultiplicationProxy

# Register MatrixMultiplicationProxy in _QuantLib:
_QuantLib.MatrixMultiplicationProxy_swigregister(MatrixMultiplicationProxy)
class BiCGstab(object):
    r"""Proxy of C++ BiCGstab class."""

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

    def solve(self, *args):
        r"""solve(BiCGstab self, Array b, Array x0=Array()) -> Array"""
        return _QuantLib.BiCGstab_solve(self, *args)

    def __init__(self, *args):
        r"""
        __init__(BiCGstab self, MatrixMultiplicationProxy proxy, Size maxIter, Real relTol) -> BiCGstab
        __init__(BiCGstab self, MatrixMultiplicationProxy proxy, Size maxIter, Real relTol, MatrixMultiplicationProxy preconditioner) -> BiCGstab
        """
        _QuantLib.BiCGstab_swiginit(self, _QuantLib.new_BiCGstab(*args))
    __swig_destroy__ = _QuantLib.delete_BiCGstab

# Register BiCGstab in _QuantLib:
_QuantLib.BiCGstab_swigregister(BiCGstab)
class GMRES(object):
    r"""Proxy of C++ GMRES class."""

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

    def solve(self, *args):
        r"""solve(GMRES self, Array b, Array x0=Array()) -> Array"""
        return _QuantLib.GMRES_solve(self, *args)

    def solveWithRestart(self, *args):
        r"""solveWithRestart(GMRES self, Size restart, Array b, Array x0=Array()) -> Array"""
        return _QuantLib.GMRES_solveWithRestart(self, *args)

    def __init__(self, *args):
        r"""
        __init__(GMRES self, MatrixMultiplicationProxy proxy, Size maxIter, Real relTol) -> GMRES
        __init__(GMRES self, MatrixMultiplicationProxy proxy, Size maxIter, Real relTol, MatrixMultiplicationProxy preconditioner) -> GMRES
        """
        _QuantLib.GMRES_swiginit(self, _QuantLib.new_GMRES(*args))
    __swig_destroy__ = _QuantLib.delete_GMRES

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

def close(*args):
    r"""
    close(Real x, Real y) -> bool
    close(Real x, Real y, Size n) -> bool
    """
    return _QuantLib.close(*args)

def close_enough(*args):
    r"""
    close_enough(Real x, Real y) -> bool
    close_enough(Real x, Real y, Size n) -> bool
    """
    return _QuantLib.close_enough(*args)
class Quote(Observable):
    r"""Proxy of C++ Quote class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def value(self):
        r"""value(Quote self) -> Real"""
        return _QuantLib.Quote_value(self)

    def isValid(self):
        r"""isValid(Quote self) -> bool"""
        return _QuantLib.Quote_isValid(self)
    __swig_destroy__ = _QuantLib.delete_Quote

# Register Quote in _QuantLib:
_QuantLib.Quote_swigregister(Quote)
class QuoteHandle(object):
    r"""Proxy of C++ Handle< Quote > class."""

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

    def __init__(self, *args):
        r"""__init__(QuoteHandle self, ext::shared_ptr< Quote > const & arg2=ext::shared_ptr()) -> QuoteHandle"""
        _QuantLib.QuoteHandle_swiginit(self, _QuantLib.new_QuoteHandle(*args))

    def __deref__(self):
        r"""__deref__(QuoteHandle self) -> ext::shared_ptr< Quote >"""
        return _QuantLib.QuoteHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(QuoteHandle self) -> ext::shared_ptr< Quote >"""
        return _QuantLib.QuoteHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(QuoteHandle self) -> bool"""
        return _QuantLib.QuoteHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(QuoteHandle self) -> bool"""
        return _QuantLib.QuoteHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(QuoteHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.QuoteHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandle

    def value(self):
        r"""value(QuoteHandle self) -> Real"""
        return _QuantLib.QuoteHandle_value(self)

    def isValid(self):
        r"""isValid(QuoteHandle self) -> bool"""
        return _QuantLib.QuoteHandle_isValid(self)

# Register QuoteHandle in _QuantLib:
_QuantLib.QuoteHandle_swigregister(QuoteHandle)
class RelinkableQuoteHandle(QuoteHandle):
    r"""Proxy of C++ RelinkableHandle< Quote > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableQuoteHandle self, ext::shared_ptr< Quote > const & arg2=ext::shared_ptr()) -> RelinkableQuoteHandle"""
        _QuantLib.RelinkableQuoteHandle_swiginit(self, _QuantLib.new_RelinkableQuoteHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableQuoteHandle self, ext::shared_ptr< Quote > const & arg2)"""
        return _QuantLib.RelinkableQuoteHandle_linkTo(self, arg2)

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

# Register RelinkableQuoteHandle in _QuantLib:
_QuantLib.RelinkableQuoteHandle_swigregister(RelinkableQuoteHandle)
class SimpleQuote(Quote):
    r"""Proxy of C++ SimpleQuote class."""

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

    def __init__(self, value):
        r"""__init__(SimpleQuote self, Real value) -> SimpleQuote"""
        _QuantLib.SimpleQuote_swiginit(self, _QuantLib.new_SimpleQuote(value))

    def setValue(self, value):
        r"""setValue(SimpleQuote self, Real value)"""
        return _QuantLib.SimpleQuote_setValue(self, value)
    __swig_destroy__ = _QuantLib.delete_SimpleQuote

# Register SimpleQuote in _QuantLib:
_QuantLib.SimpleQuote_swigregister(SimpleQuote)
class DerivedQuote(Quote):
    r"""
    Proxy of C++ DerivedQuote< UnaryFunction > class.
    Proxy of C++ DerivedQuote< UnaryFunction > class.
    """

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

    def __init__(self, h, function):
        r"""__init__(DerivedQuote self, QuoteHandle h, PyObject * function) -> DerivedQuote"""
        _QuantLib.DerivedQuote_swiginit(self, _QuantLib.new_DerivedQuote(h, function))
    __swig_destroy__ = _QuantLib.delete_DerivedQuote

# Register DerivedQuote in _QuantLib:
_QuantLib.DerivedQuote_swigregister(DerivedQuote)
class CompositeQuote(Quote):
    r"""
    Proxy of C++ CompositeQuote< BinaryFunction > class.
    Proxy of C++ CompositeQuote< BinaryFunction > class.
    """

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

    def __init__(self, h1, h2, function):
        r"""__init__(CompositeQuote self, QuoteHandle h1, QuoteHandle h2, PyObject * function) -> CompositeQuote"""
        _QuantLib.CompositeQuote_swiginit(self, _QuantLib.new_CompositeQuote(h1, h2, function))
    __swig_destroy__ = _QuantLib.delete_CompositeQuote

# Register CompositeQuote in _QuantLib:
_QuantLib.CompositeQuote_swigregister(CompositeQuote)
class QuoteVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< Quote > > class."""

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

    def iterator(self):
        r"""iterator(QuoteVector self) -> SwigPyIterator"""
        return _QuantLib.QuoteVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(QuoteVector self) -> bool"""
        return _QuantLib.QuoteVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(QuoteVector self) -> bool"""
        return _QuantLib.QuoteVector___bool__(self)

    def __len__(self):
        r"""__len__(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::size_type"""
        return _QuantLib.QuoteVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j) -> QuoteVector"""
        return _QuantLib.QuoteVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j)
        __setslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j, QuoteVector v)
        """
        return _QuantLib.QuoteVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j)"""
        return _QuantLib.QuoteVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i)
        __delitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.QuoteVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteVector
        __getitem__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i) -> std::vector< ext::shared_ptr< Quote > >::value_type const &
        """
        return _QuantLib.QuoteVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice, QuoteVector v)
        __setitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::value_type const & x)
        """
        return _QuantLib.QuoteVector___setitem__(self, *args)

    def pop(self):
        r"""pop(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::value_type"""
        return _QuantLib.QuoteVector_pop(self)

    def append(self, x):
        r"""append(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::value_type const & x)"""
        return _QuantLib.QuoteVector_append(self, x)

    def empty(self):
        r"""empty(QuoteVector self) -> bool"""
        return _QuantLib.QuoteVector_empty(self)

    def size(self):
        r"""size(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::size_type"""
        return _QuantLib.QuoteVector_size(self)

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

    def begin(self):
        r"""begin(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::iterator"""
        return _QuantLib.QuoteVector_begin(self)

    def end(self):
        r"""end(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::iterator"""
        return _QuantLib.QuoteVector_end(self)

    def rbegin(self):
        r"""rbegin(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::reverse_iterator"""
        return _QuantLib.QuoteVector_rbegin(self)

    def rend(self):
        r"""rend(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::reverse_iterator"""
        return _QuantLib.QuoteVector_rend(self)

    def clear(self):
        r"""clear(QuoteVector self)"""
        return _QuantLib.QuoteVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::allocator_type"""
        return _QuantLib.QuoteVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(QuoteVector self)"""
        return _QuantLib.QuoteVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator pos) -> std::vector< ext::shared_ptr< Quote > >::iterator
        erase(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator first, std::vector< ext::shared_ptr< Quote > >::iterator last) -> std::vector< ext::shared_ptr< Quote > >::iterator
        """
        return _QuantLib.QuoteVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(QuoteVector self) -> QuoteVector
        __init__(QuoteVector self, QuoteVector other) -> QuoteVector
        __init__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type size) -> QuoteVector
        __init__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type size, std::vector< ext::shared_ptr< Quote > >::value_type const & value) -> QuoteVector
        """
        _QuantLib.QuoteVector_swiginit(self, _QuantLib.new_QuoteVector(*args))

    def push_back(self, x):
        r"""push_back(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::value_type const & x)"""
        return _QuantLib.QuoteVector_push_back(self, x)

    def front(self):
        r"""front(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::value_type const &"""
        return _QuantLib.QuoteVector_front(self)

    def back(self):
        r"""back(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::value_type const &"""
        return _QuantLib.QuoteVector_back(self)

    def assign(self, n, x):
        r"""assign(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type n, std::vector< ext::shared_ptr< Quote > >::value_type const & x)"""
        return _QuantLib.QuoteVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type new_size)
        resize(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type new_size, std::vector< ext::shared_ptr< Quote > >::value_type const & x)
        """
        return _QuantLib.QuoteVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator pos, std::vector< ext::shared_ptr< Quote > >::value_type const & x) -> std::vector< ext::shared_ptr< Quote > >::iterator
        insert(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator pos, std::vector< ext::shared_ptr< Quote > >::size_type n, std::vector< ext::shared_ptr< Quote > >::value_type const & x)
        """
        return _QuantLib.QuoteVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type n)"""
        return _QuantLib.QuoteVector_reserve(self, n)

    def capacity(self):
        r"""capacity(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::size_type"""
        return _QuantLib.QuoteVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteVector

# Register QuoteVector in _QuantLib:
_QuantLib.QuoteVector_swigregister(QuoteVector)
class QuoteVectorVector(object):
    r"""Proxy of C++ std::vector< std::vector< ext::shared_ptr< Quote > > > class."""

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

    def iterator(self):
        r"""iterator(QuoteVectorVector self) -> SwigPyIterator"""
        return _QuantLib.QuoteVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(QuoteVectorVector self) -> bool"""
        return _QuantLib.QuoteVectorVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(QuoteVectorVector self) -> bool"""
        return _QuantLib.QuoteVectorVector___bool__(self)

    def __len__(self):
        r"""__len__(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type"""
        return _QuantLib.QuoteVectorVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j) -> QuoteVectorVector"""
        return _QuantLib.QuoteVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j)
        __setslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j, QuoteVectorVector v)
        """
        return _QuantLib.QuoteVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j)"""
        return _QuantLib.QuoteVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i)
        __delitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.QuoteVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteVectorVector
        __getitem__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i) -> QuoteVector
        """
        return _QuantLib.QuoteVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice, QuoteVectorVector v)
        __setitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, QuoteVector x)
        """
        return _QuantLib.QuoteVectorVector___setitem__(self, *args)

    def pop(self):
        r"""pop(QuoteVectorVector self) -> QuoteVector"""
        return _QuantLib.QuoteVectorVector_pop(self)

    def append(self, x):
        r"""append(QuoteVectorVector self, QuoteVector x)"""
        return _QuantLib.QuoteVectorVector_append(self, x)

    def empty(self):
        r"""empty(QuoteVectorVector self) -> bool"""
        return _QuantLib.QuoteVectorVector_empty(self)

    def size(self):
        r"""size(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type"""
        return _QuantLib.QuoteVectorVector_size(self)

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

    def begin(self):
        r"""begin(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator"""
        return _QuantLib.QuoteVectorVector_begin(self)

    def end(self):
        r"""end(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator"""
        return _QuantLib.QuoteVectorVector_end(self)

    def rbegin(self):
        r"""rbegin(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator"""
        return _QuantLib.QuoteVectorVector_rbegin(self)

    def rend(self):
        r"""rend(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator"""
        return _QuantLib.QuoteVectorVector_rend(self)

    def clear(self):
        r"""clear(QuoteVectorVector self)"""
        return _QuantLib.QuoteVectorVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::allocator_type"""
        return _QuantLib.QuoteVectorVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(QuoteVectorVector self)"""
        return _QuantLib.QuoteVectorVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator
        erase(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator first, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator last) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator
        """
        return _QuantLib.QuoteVectorVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(QuoteVectorVector self) -> QuoteVectorVector
        __init__(QuoteVectorVector self, QuoteVectorVector other) -> QuoteVectorVector
        __init__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type size) -> QuoteVectorVector
        __init__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type size, QuoteVector value) -> QuoteVectorVector
        """
        _QuantLib.QuoteVectorVector_swiginit(self, _QuantLib.new_QuoteVectorVector(*args))

    def push_back(self, x):
        r"""push_back(QuoteVectorVector self, QuoteVector x)"""
        return _QuantLib.QuoteVectorVector_push_back(self, x)

    def front(self):
        r"""front(QuoteVectorVector self) -> QuoteVector"""
        return _QuantLib.QuoteVectorVector_front(self)

    def back(self):
        r"""back(QuoteVectorVector self) -> QuoteVector"""
        return _QuantLib.QuoteVectorVector_back(self)

    def assign(self, n, x):
        r"""assign(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n, QuoteVector x)"""
        return _QuantLib.QuoteVectorVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type new_size)
        resize(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type new_size, QuoteVector x)
        """
        return _QuantLib.QuoteVectorVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos, QuoteVector x) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator
        insert(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n, QuoteVector x)
        """
        return _QuantLib.QuoteVectorVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n)"""
        return _QuantLib.QuoteVectorVector_reserve(self, n)

    def capacity(self):
        r"""capacity(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type"""
        return _QuantLib.QuoteVectorVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteVectorVector

# Register QuoteVectorVector in _QuantLib:
_QuantLib.QuoteVectorVector_swigregister(QuoteVectorVector)
class QuoteHandleVector(object):
    r"""Proxy of C++ std::vector< Handle< Quote > > class."""

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

    def iterator(self):
        r"""iterator(QuoteHandleVector self) -> SwigPyIterator"""
        return _QuantLib.QuoteHandleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(QuoteHandleVector self) -> bool"""
        return _QuantLib.QuoteHandleVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(QuoteHandleVector self) -> bool"""
        return _QuantLib.QuoteHandleVector___bool__(self)

    def __len__(self):
        r"""__len__(QuoteHandleVector self) -> std::vector< Handle< Quote > >::size_type"""
        return _QuantLib.QuoteHandleVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j) -> QuoteHandleVector"""
        return _QuantLib.QuoteHandleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j)
        __setslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j, QuoteHandleVector v)
        """
        return _QuantLib.QuoteHandleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j)"""
        return _QuantLib.QuoteHandleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i)
        __delitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.QuoteHandleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteHandleVector
        __getitem__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i) -> QuoteHandle
        """
        return _QuantLib.QuoteHandleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice, QuoteHandleVector v)
        __setitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, QuoteHandle x)
        """
        return _QuantLib.QuoteHandleVector___setitem__(self, *args)

    def pop(self):
        r"""pop(QuoteHandleVector self) -> QuoteHandle"""
        return _QuantLib.QuoteHandleVector_pop(self)

    def append(self, x):
        r"""append(QuoteHandleVector self, QuoteHandle x)"""
        return _QuantLib.QuoteHandleVector_append(self, x)

    def empty(self):
        r"""empty(QuoteHandleVector self) -> bool"""
        return _QuantLib.QuoteHandleVector_empty(self)

    def size(self):
        r"""size(QuoteHandleVector self) -> std::vector< Handle< Quote > >::size_type"""
        return _QuantLib.QuoteHandleVector_size(self)

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

    def begin(self):
        r"""begin(QuoteHandleVector self) -> std::vector< Handle< Quote > >::iterator"""
        return _QuantLib.QuoteHandleVector_begin(self)

    def end(self):
        r"""end(QuoteHandleVector self) -> std::vector< Handle< Quote > >::iterator"""
        return _QuantLib.QuoteHandleVector_end(self)

    def rbegin(self):
        r"""rbegin(QuoteHandleVector self) -> std::vector< Handle< Quote > >::reverse_iterator"""
        return _QuantLib.QuoteHandleVector_rbegin(self)

    def rend(self):
        r"""rend(QuoteHandleVector self) -> std::vector< Handle< Quote > >::reverse_iterator"""
        return _QuantLib.QuoteHandleVector_rend(self)

    def clear(self):
        r"""clear(QuoteHandleVector self)"""
        return _QuantLib.QuoteHandleVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(QuoteHandleVector self) -> std::vector< Handle< Quote > >::allocator_type"""
        return _QuantLib.QuoteHandleVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(QuoteHandleVector self)"""
        return _QuantLib.QuoteHandleVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator pos) -> std::vector< Handle< Quote > >::iterator
        erase(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator first, std::vector< Handle< Quote > >::iterator last) -> std::vector< Handle< Quote > >::iterator
        """
        return _QuantLib.QuoteHandleVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(QuoteHandleVector self) -> QuoteHandleVector
        __init__(QuoteHandleVector self, QuoteHandleVector other) -> QuoteHandleVector
        __init__(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type size) -> QuoteHandleVector
        __init__(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type size, QuoteHandle value) -> QuoteHandleVector
        """
        _QuantLib.QuoteHandleVector_swiginit(self, _QuantLib.new_QuoteHandleVector(*args))

    def push_back(self, x):
        r"""push_back(QuoteHandleVector self, QuoteHandle x)"""
        return _QuantLib.QuoteHandleVector_push_back(self, x)

    def front(self):
        r"""front(QuoteHandleVector self) -> QuoteHandle"""
        return _QuantLib.QuoteHandleVector_front(self)

    def back(self):
        r"""back(QuoteHandleVector self) -> QuoteHandle"""
        return _QuantLib.QuoteHandleVector_back(self)

    def assign(self, n, x):
        r"""assign(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type n, QuoteHandle x)"""
        return _QuantLib.QuoteHandleVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type new_size)
        resize(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type new_size, QuoteHandle x)
        """
        return _QuantLib.QuoteHandleVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator pos, QuoteHandle x) -> std::vector< Handle< Quote > >::iterator
        insert(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator pos, std::vector< Handle< Quote > >::size_type n, QuoteHandle x)
        """
        return _QuantLib.QuoteHandleVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type n)"""
        return _QuantLib.QuoteHandleVector_reserve(self, n)

    def capacity(self):
        r"""capacity(QuoteHandleVector self) -> std::vector< Handle< Quote > >::size_type"""
        return _QuantLib.QuoteHandleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandleVector

# Register QuoteHandleVector in _QuantLib:
_QuantLib.QuoteHandleVector_swigregister(QuoteHandleVector)
class QuoteHandleVectorVector(object):
    r"""Proxy of C++ std::vector< std::vector< Handle< Quote > > > class."""

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

    def iterator(self):
        r"""iterator(QuoteHandleVectorVector self) -> SwigPyIterator"""
        return _QuantLib.QuoteHandleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(QuoteHandleVectorVector self) -> bool"""
        return _QuantLib.QuoteHandleVectorVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(QuoteHandleVectorVector self) -> bool"""
        return _QuantLib.QuoteHandleVectorVector___bool__(self)

    def __len__(self):
        r"""__len__(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::size_type"""
        return _QuantLib.QuoteHandleVectorVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j) -> QuoteHandleVectorVector"""
        return _QuantLib.QuoteHandleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j)
        __setslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j, QuoteHandleVectorVector v)
        """
        return _QuantLib.QuoteHandleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j)"""
        return _QuantLib.QuoteHandleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i)
        __delitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.QuoteHandleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteHandleVectorVector
        __getitem__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i) -> QuoteHandleVector
        """
        return _QuantLib.QuoteHandleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice, QuoteHandleVectorVector v)
        __setitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, QuoteHandleVector x)
        """
        return _QuantLib.QuoteHandleVectorVector___setitem__(self, *args)

    def pop(self):
        r"""pop(QuoteHandleVectorVector self) -> QuoteHandleVector"""
        return _QuantLib.QuoteHandleVectorVector_pop(self)

    def append(self, x):
        r"""append(QuoteHandleVectorVector self, QuoteHandleVector x)"""
        return _QuantLib.QuoteHandleVectorVector_append(self, x)

    def empty(self):
        r"""empty(QuoteHandleVectorVector self) -> bool"""
        return _QuantLib.QuoteHandleVectorVector_empty(self)

    def size(self):
        r"""size(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::size_type"""
        return _QuantLib.QuoteHandleVectorVector_size(self)

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

    def begin(self):
        r"""begin(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::iterator"""
        return _QuantLib.QuoteHandleVectorVector_begin(self)

    def end(self):
        r"""end(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::iterator"""
        return _QuantLib.QuoteHandleVectorVector_end(self)

    def rbegin(self):
        r"""rbegin(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::reverse_iterator"""
        return _QuantLib.QuoteHandleVectorVector_rbegin(self)

    def rend(self):
        r"""rend(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::reverse_iterator"""
        return _QuantLib.QuoteHandleVectorVector_rend(self)

    def clear(self):
        r"""clear(QuoteHandleVectorVector self)"""
        return _QuantLib.QuoteHandleVectorVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::allocator_type"""
        return _QuantLib.QuoteHandleVectorVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(QuoteHandleVectorVector self)"""
        return _QuantLib.QuoteHandleVectorVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator pos) -> std::vector< std::vector< Handle< Quote > > >::iterator
        erase(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator first, std::vector< std::vector< Handle< Quote > > >::iterator last) -> std::vector< std::vector< Handle< Quote > > >::iterator
        """
        return _QuantLib.QuoteHandleVectorVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(QuoteHandleVectorVector self) -> QuoteHandleVectorVector
        __init__(QuoteHandleVectorVector self, QuoteHandleVectorVector other) -> QuoteHandleVectorVector
        __init__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type size) -> QuoteHandleVectorVector
        __init__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type size, QuoteHandleVector value) -> QuoteHandleVectorVector
        """
        _QuantLib.QuoteHandleVectorVector_swiginit(self, _QuantLib.new_QuoteHandleVectorVector(*args))

    def push_back(self, x):
        r"""push_back(QuoteHandleVectorVector self, QuoteHandleVector x)"""
        return _QuantLib.QuoteHandleVectorVector_push_back(self, x)

    def front(self):
        r"""front(QuoteHandleVectorVector self) -> QuoteHandleVector"""
        return _QuantLib.QuoteHandleVectorVector_front(self)

    def back(self):
        r"""back(QuoteHandleVectorVector self) -> QuoteHandleVector"""
        return _QuantLib.QuoteHandleVectorVector_back(self)

    def assign(self, n, x):
        r"""assign(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type n, QuoteHandleVector x)"""
        return _QuantLib.QuoteHandleVectorVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type new_size)
        resize(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type new_size, QuoteHandleVector x)
        """
        return _QuantLib.QuoteHandleVectorVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator pos, QuoteHandleVector x) -> std::vector< std::vector< Handle< Quote > > >::iterator
        insert(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator pos, std::vector< std::vector< Handle< Quote > > >::size_type n, QuoteHandleVector x)
        """
        return _QuantLib.QuoteHandleVectorVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type n)"""
        return _QuantLib.QuoteHandleVectorVector_reserve(self, n)

    def capacity(self):
        r"""capacity(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::size_type"""
        return _QuantLib.QuoteHandleVectorVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandleVectorVector

# Register QuoteHandleVectorVector in _QuantLib:
_QuantLib.QuoteHandleVectorVector_swigregister(QuoteHandleVectorVector)
class RelinkableQuoteHandleVector(object):
    r"""Proxy of C++ std::vector< RelinkableHandle< Quote > > class."""

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

    def iterator(self):
        r"""iterator(RelinkableQuoteHandleVector self) -> SwigPyIterator"""
        return _QuantLib.RelinkableQuoteHandleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(RelinkableQuoteHandleVector self) -> bool"""
        return _QuantLib.RelinkableQuoteHandleVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(RelinkableQuoteHandleVector self) -> bool"""
        return _QuantLib.RelinkableQuoteHandleVector___bool__(self)

    def __len__(self):
        r"""__len__(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::size_type"""
        return _QuantLib.RelinkableQuoteHandleVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j) -> RelinkableQuoteHandleVector"""
        return _QuantLib.RelinkableQuoteHandleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j)
        __setslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j, RelinkableQuoteHandleVector v)
        """
        return _QuantLib.RelinkableQuoteHandleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j)"""
        return _QuantLib.RelinkableQuoteHandleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i)
        __delitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.RelinkableQuoteHandleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice) -> RelinkableQuoteHandleVector
        __getitem__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i) -> RelinkableQuoteHandle
        """
        return _QuantLib.RelinkableQuoteHandleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice, RelinkableQuoteHandleVector v)
        __setitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, RelinkableQuoteHandle x)
        """
        return _QuantLib.RelinkableQuoteHandleVector___setitem__(self, *args)

    def pop(self):
        r"""pop(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandle"""
        return _QuantLib.RelinkableQuoteHandleVector_pop(self)

    def append(self, x):
        r"""append(RelinkableQuoteHandleVector self, RelinkableQuoteHandle x)"""
        return _QuantLib.RelinkableQuoteHandleVector_append(self, x)

    def empty(self):
        r"""empty(RelinkableQuoteHandleVector self) -> bool"""
        return _QuantLib.RelinkableQuoteHandleVector_empty(self)

    def size(self):
        r"""size(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::size_type"""
        return _QuantLib.RelinkableQuoteHandleVector_size(self)

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

    def begin(self):
        r"""begin(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::iterator"""
        return _QuantLib.RelinkableQuoteHandleVector_begin(self)

    def end(self):
        r"""end(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::iterator"""
        return _QuantLib.RelinkableQuoteHandleVector_end(self)

    def rbegin(self):
        r"""rbegin(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::reverse_iterator"""
        return _QuantLib.RelinkableQuoteHandleVector_rbegin(self)

    def rend(self):
        r"""rend(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::reverse_iterator"""
        return _QuantLib.RelinkableQuoteHandleVector_rend(self)

    def clear(self):
        r"""clear(RelinkableQuoteHandleVector self)"""
        return _QuantLib.RelinkableQuoteHandleVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::allocator_type"""
        return _QuantLib.RelinkableQuoteHandleVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(RelinkableQuoteHandleVector self)"""
        return _QuantLib.RelinkableQuoteHandleVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator pos) -> std::vector< RelinkableHandle< Quote > >::iterator
        erase(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator first, std::vector< RelinkableHandle< Quote > >::iterator last) -> std::vector< RelinkableHandle< Quote > >::iterator
        """
        return _QuantLib.RelinkableQuoteHandleVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandleVector
        __init__(RelinkableQuoteHandleVector self, RelinkableQuoteHandleVector other) -> RelinkableQuoteHandleVector
        __init__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type size) -> RelinkableQuoteHandleVector
        __init__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type size, RelinkableQuoteHandle value) -> RelinkableQuoteHandleVector
        """
        _QuantLib.RelinkableQuoteHandleVector_swiginit(self, _QuantLib.new_RelinkableQuoteHandleVector(*args))

    def push_back(self, x):
        r"""push_back(RelinkableQuoteHandleVector self, RelinkableQuoteHandle x)"""
        return _QuantLib.RelinkableQuoteHandleVector_push_back(self, x)

    def front(self):
        r"""front(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandle"""
        return _QuantLib.RelinkableQuoteHandleVector_front(self)

    def back(self):
        r"""back(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandle"""
        return _QuantLib.RelinkableQuoteHandleVector_back(self)

    def assign(self, n, x):
        r"""assign(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type n, RelinkableQuoteHandle x)"""
        return _QuantLib.RelinkableQuoteHandleVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type new_size)
        resize(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type new_size, RelinkableQuoteHandle x)
        """
        return _QuantLib.RelinkableQuoteHandleVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator pos, RelinkableQuoteHandle x) -> std::vector< RelinkableHandle< Quote > >::iterator
        insert(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator pos, std::vector< RelinkableHandle< Quote > >::size_type n, RelinkableQuoteHandle x)
        """
        return _QuantLib.RelinkableQuoteHandleVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type n)"""
        return _QuantLib.RelinkableQuoteHandleVector_reserve(self, n)

    def capacity(self):
        r"""capacity(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::size_type"""
        return _QuantLib.RelinkableQuoteHandleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandleVector

# Register RelinkableQuoteHandleVector in _QuantLib:
_QuantLib.RelinkableQuoteHandleVector_swigregister(RelinkableQuoteHandleVector)
class RelinkableQuoteHandleVectorVector(object):
    r"""Proxy of C++ std::vector< std::vector< RelinkableHandle< Quote > > > class."""

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

    def iterator(self):
        r"""iterator(RelinkableQuoteHandleVectorVector self) -> SwigPyIterator"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(RelinkableQuoteHandleVectorVector self) -> bool"""
        return _QuantLib.RelinkableQuoteHandleVectorVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(RelinkableQuoteHandleVectorVector self) -> bool"""
        return _QuantLib.RelinkableQuoteHandleVectorVector___bool__(self)

    def __len__(self):
        r"""__len__(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::size_type"""
        return _QuantLib.RelinkableQuoteHandleVectorVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j) -> RelinkableQuoteHandleVectorVector"""
        return _QuantLib.RelinkableQuoteHandleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j)
        __setslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j, RelinkableQuoteHandleVectorVector v)
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i)
        __delitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice) -> RelinkableQuoteHandleVectorVector
        __getitem__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i) -> RelinkableQuoteHandleVector
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice, RelinkableQuoteHandleVectorVector v)
        __setitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, RelinkableQuoteHandleVector x)
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector___setitem__(self, *args)

    def pop(self):
        r"""pop(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVector"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_pop(self)

    def append(self, x):
        r"""append(RelinkableQuoteHandleVectorVector self, RelinkableQuoteHandleVector x)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_append(self, x)

    def empty(self):
        r"""empty(RelinkableQuoteHandleVectorVector self) -> bool"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_empty(self)

    def size(self):
        r"""size(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::size_type"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_size(self)

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

    def begin(self):
        r"""begin(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_begin(self)

    def end(self):
        r"""end(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_end(self)

    def rbegin(self):
        r"""rbegin(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_rbegin(self)

    def rend(self):
        r"""rend(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_rend(self)

    def clear(self):
        r"""clear(RelinkableQuoteHandleVectorVector self)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::allocator_type"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(RelinkableQuoteHandleVectorVector self)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator
        erase(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator first, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator last) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVectorVector
        __init__(RelinkableQuoteHandleVectorVector self, RelinkableQuoteHandleVectorVector other) -> RelinkableQuoteHandleVectorVector
        __init__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type size) -> RelinkableQuoteHandleVectorVector
        __init__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type size, RelinkableQuoteHandleVector value) -> RelinkableQuoteHandleVectorVector
        """
        _QuantLib.RelinkableQuoteHandleVectorVector_swiginit(self, _QuantLib.new_RelinkableQuoteHandleVectorVector(*args))

    def push_back(self, x):
        r"""push_back(RelinkableQuoteHandleVectorVector self, RelinkableQuoteHandleVector x)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_push_back(self, x)

    def front(self):
        r"""front(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVector"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_front(self)

    def back(self):
        r"""back(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVector"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_back(self)

    def assign(self, n, x):
        r"""assign(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n, RelinkableQuoteHandleVector x)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type new_size)
        resize(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type new_size, RelinkableQuoteHandleVector x)
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos, RelinkableQuoteHandleVector x) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator
        insert(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n, RelinkableQuoteHandleVector x)
        """
        return _QuantLib.RelinkableQuoteHandleVectorVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n)"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_reserve(self, n)

    def capacity(self):
        r"""capacity(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::size_type"""
        return _QuantLib.RelinkableQuoteHandleVectorVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandleVectorVector

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

ModifiedFollowing = _QuantLib.ModifiedFollowing

Preceding = _QuantLib.Preceding

ModifiedPreceding = _QuantLib.ModifiedPreceding

Unadjusted = _QuantLib.Unadjusted

HalfMonthModifiedFollowing = _QuantLib.HalfMonthModifiedFollowing

Nearest = _QuantLib.Nearest

JoinHolidays = _QuantLib.JoinHolidays

JoinBusinessDays = _QuantLib.JoinBusinessDays

class Calendar(object):
    r"""Proxy of C++ Calendar class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def isWeekend(self, w):
        r"""isWeekend(Calendar self, Weekday w) -> bool"""
        return _QuantLib.Calendar_isWeekend(self, w)

    def endOfMonth(self, arg2):
        r"""endOfMonth(Calendar self, Date arg2) -> Date"""
        return _QuantLib.Calendar_endOfMonth(self, arg2)

    def isBusinessDay(self, arg2):
        r"""isBusinessDay(Calendar self, Date arg2) -> bool"""
        return _QuantLib.Calendar_isBusinessDay(self, arg2)

    def isHoliday(self, arg2):
        r"""isHoliday(Calendar self, Date arg2) -> bool"""
        return _QuantLib.Calendar_isHoliday(self, arg2)

    def isEndOfMonth(self, arg2):
        r"""isEndOfMonth(Calendar self, Date arg2) -> bool"""
        return _QuantLib.Calendar_isEndOfMonth(self, arg2)

    def addHoliday(self, arg2):
        r"""addHoliday(Calendar self, Date arg2)"""
        return _QuantLib.Calendar_addHoliday(self, arg2)

    def removeHoliday(self, arg2):
        r"""removeHoliday(Calendar self, Date arg2)"""
        return _QuantLib.Calendar_removeHoliday(self, arg2)

    def adjust(self, *args):
        r"""adjust(Calendar self, Date d, BusinessDayConvention convention=QuantLib::Following) -> Date"""
        return _QuantLib.Calendar_adjust(self, *args)

    def advance(self, *args):
        r"""
        advance(Calendar self, Date d, Integer n, TimeUnit unit, BusinessDayConvention convention=QuantLib::Following, bool endOfMonth=False) -> Date
        advance(Calendar self, Date d, Period period, BusinessDayConvention convention=QuantLib::Following, bool endOfMonth=False) -> Date
        """
        return _QuantLib.Calendar_advance(self, *args)

    def businessDaysBetween(self, _from, to, includeFirst=True, includeLast=False):
        r"""businessDaysBetween(Calendar self, Date _from, Date to, bool includeFirst=True, bool includeLast=False) -> BigInteger"""
        return _QuantLib.Calendar_businessDaysBetween(self, _from, to, includeFirst, includeLast)

    def holidayList(self, _from, to, includeWeekEnds=False):
        r"""holidayList(Calendar self, Date _from, Date to, bool includeWeekEnds=False) -> DateVector"""
        return _QuantLib.Calendar_holidayList(self, _from, to, includeWeekEnds)

    def businessDayList(self, _from, to):
        r"""businessDayList(Calendar self, Date _from, Date to) -> DateVector"""
        return _QuantLib.Calendar_businessDayList(self, _from, to)

    def name(self):
        r"""name(Calendar self) -> std::string"""
        return _QuantLib.Calendar_name(self)

    def __str__(self):
        r"""__str__(Calendar self) -> std::string"""
        return _QuantLib.Calendar___str__(self)

    def __eq__(self, other):
        r"""__eq__(Calendar self, Calendar other) -> bool"""
        return _QuantLib.Calendar___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Calendar self, Calendar other) -> bool"""
        return _QuantLib.Calendar___ne__(self, other)

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

    __swig_destroy__ = _QuantLib.delete_Calendar

# Register Calendar in _QuantLib:
_QuantLib.Calendar_swigregister(Calendar)
class Argentina(Calendar):
    r"""Proxy of C++ QuantLib::Argentina class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Merval = _QuantLib.Argentina_Merval
    

    def __init__(self, *args):
        r"""__init__(Argentina self, QuantLib::Argentina::Market m=Merval) -> Argentina"""
        _QuantLib.Argentina_swiginit(self, _QuantLib.new_Argentina(*args))
    __swig_destroy__ = _QuantLib.delete_Argentina

# Register Argentina in _QuantLib:
_QuantLib.Argentina_swigregister(Argentina)
class Australia(Calendar):
    r"""Proxy of C++ QuantLib::Australia class."""

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

    def __init__(self):
        r"""__init__(Australia self) -> Australia"""
        _QuantLib.Australia_swiginit(self, _QuantLib.new_Australia())
    __swig_destroy__ = _QuantLib.delete_Australia

# Register Australia in _QuantLib:
_QuantLib.Australia_swigregister(Australia)
class Brazil(Calendar):
    r"""Proxy of C++ QuantLib::Brazil class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.Brazil_Settlement
    
    Exchange = _QuantLib.Brazil_Exchange
    

    def __init__(self, *args):
        r"""__init__(Brazil self, QuantLib::Brazil::Market m=Settlement) -> Brazil"""
        _QuantLib.Brazil_swiginit(self, _QuantLib.new_Brazil(*args))
    __swig_destroy__ = _QuantLib.delete_Brazil

# Register Brazil in _QuantLib:
_QuantLib.Brazil_swigregister(Brazil)
class Canada(Calendar):
    r"""Proxy of C++ QuantLib::Canada class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.Canada_Settlement
    
    TSX = _QuantLib.Canada_TSX
    

    def __init__(self, *args):
        r"""__init__(Canada self, QuantLib::Canada::Market m=Settlement) -> Canada"""
        _QuantLib.Canada_swiginit(self, _QuantLib.new_Canada(*args))
    __swig_destroy__ = _QuantLib.delete_Canada

# Register Canada in _QuantLib:
_QuantLib.Canada_swigregister(Canada)
class Chile(Calendar):
    r"""Proxy of C++ QuantLib::Chile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SSE = _QuantLib.Chile_SSE
    

    def __init__(self, *args):
        r"""__init__(Chile self, QuantLib::Chile::Market m=SSE) -> Chile"""
        _QuantLib.Chile_swiginit(self, _QuantLib.new_Chile(*args))
    __swig_destroy__ = _QuantLib.delete_Chile

# Register Chile in _QuantLib:
_QuantLib.Chile_swigregister(Chile)
class China(Calendar):
    r"""Proxy of C++ QuantLib::China class."""

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

    def __init__(self, *args):
        r"""__init__(China self, QuantLib::China::Market m=SSE) -> China"""
        _QuantLib.China_swiginit(self, _QuantLib.new_China(*args))
    __swig_destroy__ = _QuantLib.delete_China

# Register China in _QuantLib:
_QuantLib.China_swigregister(China)
class CzechRepublic(Calendar):
    r"""Proxy of C++ QuantLib::CzechRepublic class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PSE = _QuantLib.CzechRepublic_PSE
    

    def __init__(self, *args):
        r"""__init__(CzechRepublic self, QuantLib::CzechRepublic::Market m=PSE) -> CzechRepublic"""
        _QuantLib.CzechRepublic_swiginit(self, _QuantLib.new_CzechRepublic(*args))
    __swig_destroy__ = _QuantLib.delete_CzechRepublic

# Register CzechRepublic in _QuantLib:
_QuantLib.CzechRepublic_swigregister(CzechRepublic)
class Denmark(Calendar):
    r"""Proxy of C++ QuantLib::Denmark class."""

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

    def __init__(self):
        r"""__init__(Denmark self) -> Denmark"""
        _QuantLib.Denmark_swiginit(self, _QuantLib.new_Denmark())
    __swig_destroy__ = _QuantLib.delete_Denmark

# Register Denmark in _QuantLib:
_QuantLib.Denmark_swigregister(Denmark)
class Finland(Calendar):
    r"""Proxy of C++ QuantLib::Finland class."""

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

    def __init__(self):
        r"""__init__(Finland self) -> Finland"""
        _QuantLib.Finland_swiginit(self, _QuantLib.new_Finland())
    __swig_destroy__ = _QuantLib.delete_Finland

# Register Finland in _QuantLib:
_QuantLib.Finland_swigregister(Finland)
class France(Calendar):
    r"""Proxy of C++ QuantLib::France class."""

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

    def __init__(self, *args):
        r"""__init__(France self, QuantLib::France::Market m=Settlement) -> France"""
        _QuantLib.France_swiginit(self, _QuantLib.new_France(*args))
    __swig_destroy__ = _QuantLib.delete_France

# Register France in _QuantLib:
_QuantLib.France_swigregister(France)
class Germany(Calendar):
    r"""Proxy of C++ QuantLib::Germany class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.Germany_Settlement
    
    FrankfurtStockExchange = _QuantLib.Germany_FrankfurtStockExchange
    
    Xetra = _QuantLib.Germany_Xetra
    
    Eurex = _QuantLib.Germany_Eurex
    

    def __init__(self, *args):
        r"""__init__(Germany self, QuantLib::Germany::Market m=FrankfurtStockExchange) -> Germany"""
        _QuantLib.Germany_swiginit(self, _QuantLib.new_Germany(*args))
    __swig_destroy__ = _QuantLib.delete_Germany

# Register Germany in _QuantLib:
_QuantLib.Germany_swigregister(Germany)
class HongKong(Calendar):
    r"""Proxy of C++ QuantLib::HongKong class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HKEx = _QuantLib.HongKong_HKEx
    

    def __init__(self, *args):
        r"""__init__(HongKong self, QuantLib::HongKong::Market m=HKEx) -> HongKong"""
        _QuantLib.HongKong_swiginit(self, _QuantLib.new_HongKong(*args))
    __swig_destroy__ = _QuantLib.delete_HongKong

# Register HongKong in _QuantLib:
_QuantLib.HongKong_swigregister(HongKong)
class Hungary(Calendar):
    r"""Proxy of C++ QuantLib::Hungary class."""

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

    def __init__(self):
        r"""__init__(Hungary self) -> Hungary"""
        _QuantLib.Hungary_swiginit(self, _QuantLib.new_Hungary())
    __swig_destroy__ = _QuantLib.delete_Hungary

# Register Hungary in _QuantLib:
_QuantLib.Hungary_swigregister(Hungary)
class Iceland(Calendar):
    r"""Proxy of C++ QuantLib::Iceland class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ICEX = _QuantLib.Iceland_ICEX
    

    def __init__(self, *args):
        r"""__init__(Iceland self, QuantLib::Iceland::Market m=ICEX) -> Iceland"""
        _QuantLib.Iceland_swiginit(self, _QuantLib.new_Iceland(*args))
    __swig_destroy__ = _QuantLib.delete_Iceland

# Register Iceland in _QuantLib:
_QuantLib.Iceland_swigregister(Iceland)
class India(Calendar):
    r"""Proxy of C++ QuantLib::India class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NSE = _QuantLib.India_NSE
    

    def __init__(self, *args):
        r"""__init__(India self, QuantLib::India::Market m=NSE) -> India"""
        _QuantLib.India_swiginit(self, _QuantLib.new_India(*args))
    __swig_destroy__ = _QuantLib.delete_India

# Register India in _QuantLib:
_QuantLib.India_swigregister(India)
class Indonesia(Calendar):
    r"""Proxy of C++ QuantLib::Indonesia class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BEJ = _QuantLib.Indonesia_BEJ
    
    JSX = _QuantLib.Indonesia_JSX
    

    def __init__(self, *args):
        r"""__init__(Indonesia self, QuantLib::Indonesia::Market m=BEJ) -> Indonesia"""
        _QuantLib.Indonesia_swiginit(self, _QuantLib.new_Indonesia(*args))
    __swig_destroy__ = _QuantLib.delete_Indonesia

# Register Indonesia in _QuantLib:
_QuantLib.Indonesia_swigregister(Indonesia)
class Israel(Calendar):
    r"""Proxy of C++ QuantLib::Israel class."""

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

    def __init__(self, *args):
        r"""__init__(Israel self, QuantLib::Israel::Market m=Settlement) -> Israel"""
        _QuantLib.Israel_swiginit(self, _QuantLib.new_Israel(*args))
    __swig_destroy__ = _QuantLib.delete_Israel

# Register Israel in _QuantLib:
_QuantLib.Israel_swigregister(Israel)
class Italy(Calendar):
    r"""Proxy of C++ QuantLib::Italy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.Italy_Settlement
    
    Exchange = _QuantLib.Italy_Exchange
    

    def __init__(self, *args):
        r"""__init__(Italy self, QuantLib::Italy::Market m=Settlement) -> Italy"""
        _QuantLib.Italy_swiginit(self, _QuantLib.new_Italy(*args))
    __swig_destroy__ = _QuantLib.delete_Italy

# Register Italy in _QuantLib:
_QuantLib.Italy_swigregister(Italy)
class Japan(Calendar):
    r"""Proxy of C++ QuantLib::Japan class."""

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

    def __init__(self):
        r"""__init__(Japan self) -> Japan"""
        _QuantLib.Japan_swiginit(self, _QuantLib.new_Japan())
    __swig_destroy__ = _QuantLib.delete_Japan

# Register Japan in _QuantLib:
_QuantLib.Japan_swigregister(Japan)
class Mexico(Calendar):
    r"""Proxy of C++ QuantLib::Mexico class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BMV = _QuantLib.Mexico_BMV
    

    def __init__(self, *args):
        r"""__init__(Mexico self, QuantLib::Mexico::Market m=BMV) -> Mexico"""
        _QuantLib.Mexico_swiginit(self, _QuantLib.new_Mexico(*args))
    __swig_destroy__ = _QuantLib.delete_Mexico

# Register Mexico in _QuantLib:
_QuantLib.Mexico_swigregister(Mexico)
class NewZealand(Calendar):
    r"""Proxy of C++ QuantLib::NewZealand class."""

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

    def __init__(self):
        r"""__init__(NewZealand self) -> NewZealand"""
        _QuantLib.NewZealand_swiginit(self, _QuantLib.new_NewZealand())
    __swig_destroy__ = _QuantLib.delete_NewZealand

# Register NewZealand in _QuantLib:
_QuantLib.NewZealand_swigregister(NewZealand)
class Norway(Calendar):
    r"""Proxy of C++ QuantLib::Norway class."""

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

    def __init__(self):
        r"""__init__(Norway self) -> Norway"""
        _QuantLib.Norway_swiginit(self, _QuantLib.new_Norway())
    __swig_destroy__ = _QuantLib.delete_Norway

# Register Norway in _QuantLib:
_QuantLib.Norway_swigregister(Norway)
class Poland(Calendar):
    r"""Proxy of C++ QuantLib::Poland class."""

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

    def __init__(self):
        r"""__init__(Poland self) -> Poland"""
        _QuantLib.Poland_swiginit(self, _QuantLib.new_Poland())
    __swig_destroy__ = _QuantLib.delete_Poland

# Register Poland in _QuantLib:
_QuantLib.Poland_swigregister(Poland)
class Russia(Calendar):
    r"""Proxy of C++ QuantLib::Russia class."""

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

    def __init__(self, *args):
        r"""__init__(Russia self, QuantLib::Russia::Market m=Settlement) -> Russia"""
        _QuantLib.Russia_swiginit(self, _QuantLib.new_Russia(*args))
    __swig_destroy__ = _QuantLib.delete_Russia

# Register Russia in _QuantLib:
_QuantLib.Russia_swigregister(Russia)
class Romania(Calendar):
    r"""Proxy of C++ QuantLib::Romania class."""

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

    def __init__(self):
        r"""__init__(Romania self) -> Romania"""
        _QuantLib.Romania_swiginit(self, _QuantLib.new_Romania())
    __swig_destroy__ = _QuantLib.delete_Romania

# Register Romania in _QuantLib:
_QuantLib.Romania_swigregister(Romania)
class SaudiArabia(Calendar):
    r"""Proxy of C++ QuantLib::SaudiArabia class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Tadawul = _QuantLib.SaudiArabia_Tadawul
    

    def __init__(self, *args):
        r"""__init__(SaudiArabia self, QuantLib::SaudiArabia::Market m=Tadawul) -> SaudiArabia"""
        _QuantLib.SaudiArabia_swiginit(self, _QuantLib.new_SaudiArabia(*args))
    __swig_destroy__ = _QuantLib.delete_SaudiArabia

# Register SaudiArabia in _QuantLib:
_QuantLib.SaudiArabia_swigregister(SaudiArabia)
class Singapore(Calendar):
    r"""Proxy of C++ QuantLib::Singapore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SGX = _QuantLib.Singapore_SGX
    

    def __init__(self, *args):
        r"""__init__(Singapore self, QuantLib::Singapore::Market m=SGX) -> Singapore"""
        _QuantLib.Singapore_swiginit(self, _QuantLib.new_Singapore(*args))
    __swig_destroy__ = _QuantLib.delete_Singapore

# Register Singapore in _QuantLib:
_QuantLib.Singapore_swigregister(Singapore)
class Slovakia(Calendar):
    r"""Proxy of C++ QuantLib::Slovakia class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BSSE = _QuantLib.Slovakia_BSSE
    

    def __init__(self, *args):
        r"""__init__(Slovakia self, QuantLib::Slovakia::Market m=BSSE) -> Slovakia"""
        _QuantLib.Slovakia_swiginit(self, _QuantLib.new_Slovakia(*args))
    __swig_destroy__ = _QuantLib.delete_Slovakia

# Register Slovakia in _QuantLib:
_QuantLib.Slovakia_swigregister(Slovakia)
class SouthAfrica(Calendar):
    r"""Proxy of C++ QuantLib::SouthAfrica class."""

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

    def __init__(self):
        r"""__init__(SouthAfrica self) -> SouthAfrica"""
        _QuantLib.SouthAfrica_swiginit(self, _QuantLib.new_SouthAfrica())
    __swig_destroy__ = _QuantLib.delete_SouthAfrica

# Register SouthAfrica in _QuantLib:
_QuantLib.SouthAfrica_swigregister(SouthAfrica)
class SouthKorea(Calendar):
    r"""Proxy of C++ QuantLib::SouthKorea class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.SouthKorea_Settlement
    
    KRX = _QuantLib.SouthKorea_KRX
    

    def __init__(self, *args):
        r"""__init__(SouthKorea self, QuantLib::SouthKorea::Market m=KRX) -> SouthKorea"""
        _QuantLib.SouthKorea_swiginit(self, _QuantLib.new_SouthKorea(*args))
    __swig_destroy__ = _QuantLib.delete_SouthKorea

# Register SouthKorea in _QuantLib:
_QuantLib.SouthKorea_swigregister(SouthKorea)
class Sweden(Calendar):
    r"""Proxy of C++ QuantLib::Sweden class."""

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

    def __init__(self):
        r"""__init__(Sweden self) -> Sweden"""
        _QuantLib.Sweden_swiginit(self, _QuantLib.new_Sweden())
    __swig_destroy__ = _QuantLib.delete_Sweden

# Register Sweden in _QuantLib:
_QuantLib.Sweden_swigregister(Sweden)
class Switzerland(Calendar):
    r"""Proxy of C++ QuantLib::Switzerland class."""

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

    def __init__(self):
        r"""__init__(Switzerland self) -> Switzerland"""
        _QuantLib.Switzerland_swiginit(self, _QuantLib.new_Switzerland())
    __swig_destroy__ = _QuantLib.delete_Switzerland

# Register Switzerland in _QuantLib:
_QuantLib.Switzerland_swigregister(Switzerland)
class Taiwan(Calendar):
    r"""Proxy of C++ QuantLib::Taiwan class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TSEC = _QuantLib.Taiwan_TSEC
    

    def __init__(self, *args):
        r"""__init__(Taiwan self, QuantLib::Taiwan::Market m=TSEC) -> Taiwan"""
        _QuantLib.Taiwan_swiginit(self, _QuantLib.new_Taiwan(*args))
    __swig_destroy__ = _QuantLib.delete_Taiwan

# Register Taiwan in _QuantLib:
_QuantLib.Taiwan_swigregister(Taiwan)
class TARGET(Calendar):
    r"""Proxy of C++ QuantLib::TARGET class."""

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

    def __init__(self):
        r"""__init__(TARGET self) -> TARGET"""
        _QuantLib.TARGET_swiginit(self, _QuantLib.new_TARGET())
    __swig_destroy__ = _QuantLib.delete_TARGET

# Register TARGET in _QuantLib:
_QuantLib.TARGET_swigregister(TARGET)
class Thailand(Calendar):
    r"""Proxy of C++ QuantLib::Thailand class."""

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

    def __init__(self):
        r"""__init__(Thailand self) -> Thailand"""
        _QuantLib.Thailand_swiginit(self, _QuantLib.new_Thailand())
    __swig_destroy__ = _QuantLib.delete_Thailand

# Register Thailand in _QuantLib:
_QuantLib.Thailand_swigregister(Thailand)
class Turkey(Calendar):
    r"""Proxy of C++ QuantLib::Turkey class."""

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

    def __init__(self):
        r"""__init__(Turkey self) -> Turkey"""
        _QuantLib.Turkey_swiginit(self, _QuantLib.new_Turkey())
    __swig_destroy__ = _QuantLib.delete_Turkey

# Register Turkey in _QuantLib:
_QuantLib.Turkey_swigregister(Turkey)
class Ukraine(Calendar):
    r"""Proxy of C++ QuantLib::Ukraine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    USE = _QuantLib.Ukraine_USE
    

    def __init__(self, *args):
        r"""__init__(Ukraine self, QuantLib::Ukraine::Market m=USE) -> Ukraine"""
        _QuantLib.Ukraine_swiginit(self, _QuantLib.new_Ukraine(*args))
    __swig_destroy__ = _QuantLib.delete_Ukraine

# Register Ukraine in _QuantLib:
_QuantLib.Ukraine_swigregister(Ukraine)
class UnitedKingdom(Calendar):
    r"""Proxy of C++ QuantLib::UnitedKingdom class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.UnitedKingdom_Settlement
    
    Exchange = _QuantLib.UnitedKingdom_Exchange
    
    Metals = _QuantLib.UnitedKingdom_Metals
    

    def __init__(self, *args):
        r"""__init__(UnitedKingdom self, QuantLib::UnitedKingdom::Market m=Settlement) -> UnitedKingdom"""
        _QuantLib.UnitedKingdom_swiginit(self, _QuantLib.new_UnitedKingdom(*args))
    __swig_destroy__ = _QuantLib.delete_UnitedKingdom

# Register UnitedKingdom in _QuantLib:
_QuantLib.UnitedKingdom_swigregister(UnitedKingdom)
class UnitedStates(Calendar):
    r"""Proxy of C++ QuantLib::UnitedStates class."""

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

    def __init__(self, m):
        r"""__init__(UnitedStates self, QuantLib::UnitedStates::Market m) -> UnitedStates"""
        _QuantLib.UnitedStates_swiginit(self, _QuantLib.new_UnitedStates(m))
    __swig_destroy__ = _QuantLib.delete_UnitedStates

# Register UnitedStates in _QuantLib:
_QuantLib.UnitedStates_swigregister(UnitedStates)
class NullCalendar(Calendar):
    r"""Proxy of C++ QuantLib::NullCalendar class."""

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

    def __init__(self):
        r"""__init__(NullCalendar self) -> NullCalendar"""
        _QuantLib.NullCalendar_swiginit(self, _QuantLib.new_NullCalendar())
    __swig_destroy__ = _QuantLib.delete_NullCalendar

# Register NullCalendar in _QuantLib:
_QuantLib.NullCalendar_swigregister(NullCalendar)
class WeekendsOnly(Calendar):
    r"""Proxy of C++ QuantLib::WeekendsOnly class."""

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

    def __init__(self):
        r"""__init__(WeekendsOnly self) -> WeekendsOnly"""
        _QuantLib.WeekendsOnly_swiginit(self, _QuantLib.new_WeekendsOnly())
    __swig_destroy__ = _QuantLib.delete_WeekendsOnly

# Register WeekendsOnly in _QuantLib:
_QuantLib.WeekendsOnly_swigregister(WeekendsOnly)
class JointCalendar(Calendar):
    r"""Proxy of C++ QuantLib::JointCalendar class."""

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

    def __init__(self, *args):
        r"""
        __init__(JointCalendar self, Calendar arg2, Calendar arg3, JointCalendarRule rule=QuantLib::JoinHolidays) -> JointCalendar
        __init__(JointCalendar self, Calendar arg2, Calendar arg3, Calendar arg4, JointCalendarRule rule=QuantLib::JoinHolidays) -> JointCalendar
        __init__(JointCalendar self, Calendar arg2, Calendar arg3, Calendar arg4, Calendar arg5, JointCalendarRule rule=QuantLib::JoinHolidays) -> JointCalendar
        """
        _QuantLib.JointCalendar_swiginit(self, _QuantLib.new_JointCalendar(*args))
    __swig_destroy__ = _QuantLib.delete_JointCalendar

# Register JointCalendar in _QuantLib:
_QuantLib.JointCalendar_swigregister(JointCalendar)
class BespokeCalendar(Calendar):
    r"""Proxy of C++ QuantLib::BespokeCalendar class."""

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

    def __init__(self, name):
        r"""__init__(BespokeCalendar self, std::string const & name) -> BespokeCalendar"""
        _QuantLib.BespokeCalendar_swiginit(self, _QuantLib.new_BespokeCalendar(name))

    def addWeekend(self, arg2):
        r"""addWeekend(BespokeCalendar self, Weekday arg2)"""
        return _QuantLib.BespokeCalendar_addWeekend(self, arg2)
    __swig_destroy__ = _QuantLib.delete_BespokeCalendar

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

def nullInt():
    r"""nullInt() -> int"""
    return _QuantLib.nullInt()

def nullDouble():
    r"""nullDouble() -> double"""
    return _QuantLib.nullDouble()
class DayCounter(object):
    r"""Proxy of C++ DayCounter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def dayCount(self, d1, d2):
        r"""dayCount(DayCounter self, Date d1, Date d2) -> BigInteger"""
        return _QuantLib.DayCounter_dayCount(self, d1, d2)

    def yearFraction(self, *args):
        r"""yearFraction(DayCounter self, Date d1, Date d2, Date startRef=Date(), Date endRef=Date()) -> Time"""
        return _QuantLib.DayCounter_yearFraction(self, *args)

    def name(self):
        r"""name(DayCounter self) -> std::string"""
        return _QuantLib.DayCounter_name(self)

    def __str__(self):
        r"""__str__(DayCounter self) -> std::string"""
        return _QuantLib.DayCounter___str__(self)

    def __eq__(self, other):
        r"""__eq__(DayCounter self, DayCounter other) -> bool"""
        return _QuantLib.DayCounter___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DayCounter self, DayCounter other) -> bool"""
        return _QuantLib.DayCounter___ne__(self, other)

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

    __swig_destroy__ = _QuantLib.delete_DayCounter

# Register DayCounter in _QuantLib:
_QuantLib.DayCounter_swigregister(DayCounter)
class Actual360(DayCounter):
    r"""Proxy of C++ QuantLib::Actual360 class."""

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

    def __init__(self, includeLastDay=False):
        r"""__init__(Actual360 self, bool const includeLastDay=False) -> Actual360"""
        _QuantLib.Actual360_swiginit(self, _QuantLib.new_Actual360(includeLastDay))
    __swig_destroy__ = _QuantLib.delete_Actual360

# Register Actual360 in _QuantLib:
_QuantLib.Actual360_swigregister(Actual360)
class Actual366(DayCounter):
    r"""Proxy of C++ QuantLib::Actual366 class."""

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

    def __init__(self, includeLastDay=False):
        r"""__init__(Actual366 self, bool const includeLastDay=False) -> Actual366"""
        _QuantLib.Actual366_swiginit(self, _QuantLib.new_Actual366(includeLastDay))
    __swig_destroy__ = _QuantLib.delete_Actual366

# Register Actual366 in _QuantLib:
_QuantLib.Actual366_swigregister(Actual366)
class Actual36525(DayCounter):
    r"""Proxy of C++ QuantLib::Actual36525 class."""

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

    def __init__(self, includeLastDay=False):
        r"""__init__(Actual36525 self, bool const includeLastDay=False) -> Actual36525"""
        _QuantLib.Actual36525_swiginit(self, _QuantLib.new_Actual36525(includeLastDay))
    __swig_destroy__ = _QuantLib.delete_Actual36525

# Register Actual36525 in _QuantLib:
_QuantLib.Actual36525_swigregister(Actual36525)
class Actual364(DayCounter):
    r"""Proxy of C++ QuantLib::Actual364 class."""

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

    def __init__(self):
        r"""__init__(Actual364 self) -> Actual364"""
        _QuantLib.Actual364_swiginit(self, _QuantLib.new_Actual364())
    __swig_destroy__ = _QuantLib.delete_Actual364

# Register Actual364 in _QuantLib:
_QuantLib.Actual364_swigregister(Actual364)
class Actual365Fixed(DayCounter):
    r"""Proxy of C++ QuantLib::Actual365Fixed class."""

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

    def __init__(self, *args):
        r"""__init__(Actual365Fixed self, QuantLib::Actual365Fixed::Convention c=Standard) -> Actual365Fixed"""
        _QuantLib.Actual365Fixed_swiginit(self, _QuantLib.new_Actual365Fixed(*args))
    __swig_destroy__ = _QuantLib.delete_Actual365Fixed

# Register Actual365Fixed in _QuantLib:
_QuantLib.Actual365Fixed_swigregister(Actual365Fixed)
class Thirty360(DayCounter):
    r"""Proxy of C++ QuantLib::Thirty360 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    USA = _QuantLib.Thirty360_USA
    
    BondBasis = _QuantLib.Thirty360_BondBasis
    
    European = _QuantLib.Thirty360_European
    
    EurobondBasis = _QuantLib.Thirty360_EurobondBasis
    
    Italian = _QuantLib.Thirty360_Italian
    
    German = _QuantLib.Thirty360_German
    
    ISMA = _QuantLib.Thirty360_ISMA
    
    ISDA = _QuantLib.Thirty360_ISDA
    
    NASD = _QuantLib.Thirty360_NASD
    

    def __init__(self, *args):
        r"""__init__(Thirty360 self, QuantLib::Thirty360::Convention c, Date terminationDate=Date()) -> Thirty360"""
        _QuantLib.Thirty360_swiginit(self, _QuantLib.new_Thirty360(*args))
    __swig_destroy__ = _QuantLib.delete_Thirty360

# Register Thirty360 in _QuantLib:
_QuantLib.Thirty360_swigregister(Thirty360)
class Thirty365(DayCounter):
    r"""Proxy of C++ QuantLib::Thirty365 class."""

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

    def __init__(self):
        r"""__init__(Thirty365 self) -> Thirty365"""
        _QuantLib.Thirty365_swiginit(self, _QuantLib.new_Thirty365())
    __swig_destroy__ = _QuantLib.delete_Thirty365

# Register Thirty365 in _QuantLib:
_QuantLib.Thirty365_swigregister(Thirty365)
class ActualActual(DayCounter):
    r"""Proxy of C++ QuantLib::ActualActual class."""

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

    def __init__(self, *args):
        r"""__init__(ActualActual self, QuantLib::ActualActual::Convention c, Schedule schedule=Schedule()) -> ActualActual"""
        _QuantLib.ActualActual_swiginit(self, _QuantLib.new_ActualActual(*args))
    __swig_destroy__ = _QuantLib.delete_ActualActual

# Register ActualActual in _QuantLib:
_QuantLib.ActualActual_swigregister(ActualActual)
class OneDayCounter(DayCounter):
    r"""Proxy of C++ QuantLib::OneDayCounter class."""

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

    def __init__(self):
        r"""__init__(OneDayCounter self) -> OneDayCounter"""
        _QuantLib.OneDayCounter_swiginit(self, _QuantLib.new_OneDayCounter())
    __swig_destroy__ = _QuantLib.delete_OneDayCounter

# Register OneDayCounter in _QuantLib:
_QuantLib.OneDayCounter_swigregister(OneDayCounter)
class SimpleDayCounter(DayCounter):
    r"""Proxy of C++ QuantLib::SimpleDayCounter class."""

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

    def __init__(self):
        r"""__init__(SimpleDayCounter self) -> SimpleDayCounter"""
        _QuantLib.SimpleDayCounter_swiginit(self, _QuantLib.new_SimpleDayCounter())
    __swig_destroy__ = _QuantLib.delete_SimpleDayCounter

# Register SimpleDayCounter in _QuantLib:
_QuantLib.SimpleDayCounter_swigregister(SimpleDayCounter)
class Business252(DayCounter):
    r"""Proxy of C++ QuantLib::Business252 class."""

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

    def __init__(self, *args):
        r"""__init__(Business252 self, Calendar c=QuantLib::Brazil()) -> Business252"""
        _QuantLib.Business252_swiginit(self, _QuantLib.new_Business252(*args))
    __swig_destroy__ = _QuantLib.delete_Business252

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

Compounded = _QuantLib.Compounded

Continuous = _QuantLib.Continuous

SimpleThenCompounded = _QuantLib.SimpleThenCompounded

CompoundedThenSimple = _QuantLib.CompoundedThenSimple

class InterestRate(object):
    r"""Proxy of C++ InterestRate class."""

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

    def __init__(self, *args):
        r"""
        __init__(InterestRate self) -> InterestRate
        __init__(InterestRate self, Rate r, DayCounter dc, Compounding comp, Frequency freq) -> InterestRate
        """
        _QuantLib.InterestRate_swiginit(self, _QuantLib.new_InterestRate(*args))

    def rate(self):
        r"""rate(InterestRate self) -> Rate"""
        return _QuantLib.InterestRate_rate(self)

    def dayCounter(self):
        r"""dayCounter(InterestRate self) -> DayCounter"""
        return _QuantLib.InterestRate_dayCounter(self)

    def compounding(self):
        r"""compounding(InterestRate self) -> Compounding"""
        return _QuantLib.InterestRate_compounding(self)

    def frequency(self):
        r"""frequency(InterestRate self) -> Frequency"""
        return _QuantLib.InterestRate_frequency(self)

    def discountFactor(self, *args):
        r"""
        discountFactor(InterestRate self, Time t) -> DiscountFactor
        discountFactor(InterestRate self, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> DiscountFactor
        """
        return _QuantLib.InterestRate_discountFactor(self, *args)

    def compoundFactor(self, *args):
        r"""
        compoundFactor(InterestRate self, Time t) -> Real
        compoundFactor(InterestRate self, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> Real
        """
        return _QuantLib.InterestRate_compoundFactor(self, *args)

    @staticmethod
    def impliedRate(*args):
        r"""
        impliedRate(Real compound, DayCounter resultDC, Compounding comp, Frequency freq, Time t) -> InterestRate
        impliedRate(Real compound, DayCounter resultDC, Compounding comp, Frequency freq, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> InterestRate
        """
        return _QuantLib.InterestRate_impliedRate(*args)

    def equivalentRate(self, *args):
        r"""
        equivalentRate(InterestRate self, Compounding comp, Frequency freq, Time t) -> InterestRate
        equivalentRate(InterestRate self, DayCounter resultDayCounter, Compounding comp, Frequency freq, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> InterestRate
        """
        return _QuantLib.InterestRate_equivalentRate(self, *args)

    def __str__(self):
        r"""__str__(InterestRate self) -> std::string"""
        return _QuantLib.InterestRate___str__(self)
    __swig_destroy__ = _QuantLib.delete_InterestRate

# Register InterestRate in _QuantLib:
_QuantLib.InterestRate_swigregister(InterestRate)
class InterestRateVector(object):
    r"""Proxy of C++ std::vector< InterestRate > class."""

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

    def iterator(self):
        r"""iterator(InterestRateVector self) -> SwigPyIterator"""
        return _QuantLib.InterestRateVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(InterestRateVector self) -> bool"""
        return _QuantLib.InterestRateVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(InterestRateVector self) -> bool"""
        return _QuantLib.InterestRateVector___bool__(self)

    def __len__(self):
        r"""__len__(InterestRateVector self) -> std::vector< InterestRate >::size_type"""
        return _QuantLib.InterestRateVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j) -> InterestRateVector"""
        return _QuantLib.InterestRateVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j)
        __setslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j, InterestRateVector v)
        """
        return _QuantLib.InterestRateVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j)"""
        return _QuantLib.InterestRateVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(InterestRateVector self, std::vector< InterestRate >::difference_type i)
        __delitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.InterestRateVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice) -> InterestRateVector
        __getitem__(InterestRateVector self, std::vector< InterestRate >::difference_type i) -> InterestRate
        """
        return _QuantLib.InterestRateVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice, InterestRateVector v)
        __setitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(InterestRateVector self, std::vector< InterestRate >::difference_type i, InterestRate x)
        """
        return _QuantLib.InterestRateVector___setitem__(self, *args)

    def pop(self):
        r"""pop(InterestRateVector self) -> InterestRate"""
        return _QuantLib.InterestRateVector_pop(self)

    def append(self, x):
        r"""append(InterestRateVector self, InterestRate x)"""
        return _QuantLib.InterestRateVector_append(self, x)

    def empty(self):
        r"""empty(InterestRateVector self) -> bool"""
        return _QuantLib.InterestRateVector_empty(self)

    def size(self):
        r"""size(InterestRateVector self) -> std::vector< InterestRate >::size_type"""
        return _QuantLib.InterestRateVector_size(self)

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

    def begin(self):
        r"""begin(InterestRateVector self) -> std::vector< InterestRate >::iterator"""
        return _QuantLib.InterestRateVector_begin(self)

    def end(self):
        r"""end(InterestRateVector self) -> std::vector< InterestRate >::iterator"""
        return _QuantLib.InterestRateVector_end(self)

    def rbegin(self):
        r"""rbegin(InterestRateVector self) -> std::vector< InterestRate >::reverse_iterator"""
        return _QuantLib.InterestRateVector_rbegin(self)

    def rend(self):
        r"""rend(InterestRateVector self) -> std::vector< InterestRate >::reverse_iterator"""
        return _QuantLib.InterestRateVector_rend(self)

    def clear(self):
        r"""clear(InterestRateVector self)"""
        return _QuantLib.InterestRateVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(InterestRateVector self) -> std::vector< InterestRate >::allocator_type"""
        return _QuantLib.InterestRateVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(InterestRateVector self)"""
        return _QuantLib.InterestRateVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(InterestRateVector self, std::vector< InterestRate >::iterator pos) -> std::vector< InterestRate >::iterator
        erase(InterestRateVector self, std::vector< InterestRate >::iterator first, std::vector< InterestRate >::iterator last) -> std::vector< InterestRate >::iterator
        """
        return _QuantLib.InterestRateVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(InterestRateVector self) -> InterestRateVector
        __init__(InterestRateVector self, InterestRateVector other) -> InterestRateVector
        __init__(InterestRateVector self, std::vector< InterestRate >::size_type size) -> InterestRateVector
        __init__(InterestRateVector self, std::vector< InterestRate >::size_type size, InterestRate value) -> InterestRateVector
        """
        _QuantLib.InterestRateVector_swiginit(self, _QuantLib.new_InterestRateVector(*args))

    def push_back(self, x):
        r"""push_back(InterestRateVector self, InterestRate x)"""
        return _QuantLib.InterestRateVector_push_back(self, x)

    def front(self):
        r"""front(InterestRateVector self) -> InterestRate"""
        return _QuantLib.InterestRateVector_front(self)

    def back(self):
        r"""back(InterestRateVector self) -> InterestRate"""
        return _QuantLib.InterestRateVector_back(self)

    def assign(self, n, x):
        r"""assign(InterestRateVector self, std::vector< InterestRate >::size_type n, InterestRate x)"""
        return _QuantLib.InterestRateVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(InterestRateVector self, std::vector< InterestRate >::size_type new_size)
        resize(InterestRateVector self, std::vector< InterestRate >::size_type new_size, InterestRate x)
        """
        return _QuantLib.InterestRateVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(InterestRateVector self, std::vector< InterestRate >::iterator pos, InterestRate x) -> std::vector< InterestRate >::iterator
        insert(InterestRateVector self, std::vector< InterestRate >::iterator pos, std::vector< InterestRate >::size_type n, InterestRate x)
        """
        return _QuantLib.InterestRateVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(InterestRateVector self, std::vector< InterestRate >::size_type n)"""
        return _QuantLib.InterestRateVector_reserve(self, n)

    def capacity(self):
        r"""capacity(InterestRateVector self) -> std::vector< InterestRate >::size_type"""
        return _QuantLib.InterestRateVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_InterestRateVector

# Register InterestRateVector in _QuantLib:
_QuantLib.InterestRateVector_swigregister(InterestRateVector)
class Rounding(object):
    r"""Proxy of C++ Rounding class."""

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

    def __init__(self):
        r"""__init__(Rounding self) -> Rounding"""
        _QuantLib.Rounding_swiginit(self, _QuantLib.new_Rounding())

    def __call__(self, value):
        r"""__call__(Rounding self, Decimal value) -> Decimal"""
        return _QuantLib.Rounding___call__(self, value)
    __swig_destroy__ = _QuantLib.delete_Rounding

# Register Rounding in _QuantLib:
_QuantLib.Rounding_swigregister(Rounding)
class UpRounding(Rounding):
    r"""Proxy of C++ UpRounding class."""

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

    def __init__(self, precision, digit=5):
        r"""__init__(UpRounding self, Integer precision, Integer digit=5) -> UpRounding"""
        _QuantLib.UpRounding_swiginit(self, _QuantLib.new_UpRounding(precision, digit))
    __swig_destroy__ = _QuantLib.delete_UpRounding

# Register UpRounding in _QuantLib:
_QuantLib.UpRounding_swigregister(UpRounding)
class DownRounding(Rounding):
    r"""Proxy of C++ DownRounding class."""

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

    def __init__(self, precision, digit=5):
        r"""__init__(DownRounding self, Integer precision, Integer digit=5) -> DownRounding"""
        _QuantLib.DownRounding_swiginit(self, _QuantLib.new_DownRounding(precision, digit))
    __swig_destroy__ = _QuantLib.delete_DownRounding

# Register DownRounding in _QuantLib:
_QuantLib.DownRounding_swigregister(DownRounding)
class ClosestRounding(Rounding):
    r"""Proxy of C++ ClosestRounding class."""

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

    def __init__(self, precision, digit=5):
        r"""__init__(ClosestRounding self, Integer precision, Integer digit=5) -> ClosestRounding"""
        _QuantLib.ClosestRounding_swiginit(self, _QuantLib.new_ClosestRounding(precision, digit))
    __swig_destroy__ = _QuantLib.delete_ClosestRounding

# Register ClosestRounding in _QuantLib:
_QuantLib.ClosestRounding_swigregister(ClosestRounding)
class CeilingTruncation(Rounding):
    r"""Proxy of C++ CeilingTruncation class."""

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

    def __init__(self, precision, digit=5):
        r"""__init__(CeilingTruncation self, Integer precision, Integer digit=5) -> CeilingTruncation"""
        _QuantLib.CeilingTruncation_swiginit(self, _QuantLib.new_CeilingTruncation(precision, digit))
    __swig_destroy__ = _QuantLib.delete_CeilingTruncation

# Register CeilingTruncation in _QuantLib:
_QuantLib.CeilingTruncation_swigregister(CeilingTruncation)
class FloorTruncation(Rounding):
    r"""Proxy of C++ FloorTruncation class."""

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

    def __init__(self, precision, digit=5):
        r"""__init__(FloorTruncation self, Integer precision, Integer digit=5) -> FloorTruncation"""
        _QuantLib.FloorTruncation_swiginit(self, _QuantLib.new_FloorTruncation(precision, digit))
    __swig_destroy__ = _QuantLib.delete_FloorTruncation

# Register FloorTruncation in _QuantLib:
_QuantLib.FloorTruncation_swigregister(FloorTruncation)
class Currency(object):
    r"""Proxy of C++ Currency class."""

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

    def __init__(self, *args):
        r"""
        __init__(Currency self) -> Currency
        __init__(Currency self, std::string const & name, std::string const & code, Integer numericCode, std::string const & symbol, std::string const & fractionSymbol, Integer fractionsPerUnit, Rounding rounding, std::string const & formatString, Currency triangulationCurrency=Currency()) -> Currency
        """
        _QuantLib.Currency_swiginit(self, _QuantLib.new_Currency(*args))

    def name(self):
        r"""name(Currency self) -> std::string const &"""
        return _QuantLib.Currency_name(self)

    def code(self):
        r"""code(Currency self) -> std::string const &"""
        return _QuantLib.Currency_code(self)

    def numericCode(self):
        r"""numericCode(Currency self) -> Integer"""
        return _QuantLib.Currency_numericCode(self)

    def symbol(self):
        r"""symbol(Currency self) -> std::string const &"""
        return _QuantLib.Currency_symbol(self)

    def fractionSymbol(self):
        r"""fractionSymbol(Currency self) -> std::string const &"""
        return _QuantLib.Currency_fractionSymbol(self)

    def fractionsPerUnit(self):
        r"""fractionsPerUnit(Currency self) -> Integer"""
        return _QuantLib.Currency_fractionsPerUnit(self)

    def rounding(self):
        r"""rounding(Currency self) -> Rounding"""
        return _QuantLib.Currency_rounding(self)

    def format(self):
        r"""format(Currency self) -> std::string"""
        return _QuantLib.Currency_format(self)

    def empty(self):
        r"""empty(Currency self) -> bool"""
        return _QuantLib.Currency_empty(self)

    def triangulationCurrency(self):
        r"""triangulationCurrency(Currency self) -> Currency"""
        return _QuantLib.Currency_triangulationCurrency(self)

    def __str__(self):
        r"""__str__(Currency self) -> std::string"""
        return _QuantLib.Currency___str__(self)

    def __eq__(self, other):
        r"""__eq__(Currency self, Currency other) -> bool"""
        return _QuantLib.Currency___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Currency self, Currency other) -> bool"""
        return _QuantLib.Currency___ne__(self, other)

    def __mul__(self, x):
        r"""__mul__(Currency self, Decimal x) -> Money"""
        return _QuantLib.Currency___mul__(self, x)

    def __rmul__(self, x):
        r"""__rmul__(Currency self, Decimal x) -> Money"""
        return _QuantLib.Currency___rmul__(self, x)

    def __nonzero__(self):
        r"""__nonzero__(Currency self) -> bool"""
        return _QuantLib.Currency___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Currency self) -> bool"""
        return _QuantLib.Currency___bool__(self)

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

    __swig_destroy__ = _QuantLib.delete_Currency

# Register Currency in _QuantLib:
_QuantLib.Currency_swigregister(Currency)
class ARSCurrency(Currency):
    r"""Proxy of C++ QuantLib::ARSCurrency class."""

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

    def __init__(self):
        r"""__init__(ARSCurrency self) -> ARSCurrency"""
        _QuantLib.ARSCurrency_swiginit(self, _QuantLib.new_ARSCurrency())
    __swig_destroy__ = _QuantLib.delete_ARSCurrency

# Register ARSCurrency in _QuantLib:
_QuantLib.ARSCurrency_swigregister(ARSCurrency)
class ATSCurrency(Currency):
    r"""Proxy of C++ QuantLib::ATSCurrency class."""

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

    def __init__(self):
        r"""__init__(ATSCurrency self) -> ATSCurrency"""
        _QuantLib.ATSCurrency_swiginit(self, _QuantLib.new_ATSCurrency())
    __swig_destroy__ = _QuantLib.delete_ATSCurrency

# Register ATSCurrency in _QuantLib:
_QuantLib.ATSCurrency_swigregister(ATSCurrency)
class AUDCurrency(Currency):
    r"""Proxy of C++ QuantLib::AUDCurrency class."""

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

    def __init__(self):
        r"""__init__(AUDCurrency self) -> AUDCurrency"""
        _QuantLib.AUDCurrency_swiginit(self, _QuantLib.new_AUDCurrency())
    __swig_destroy__ = _QuantLib.delete_AUDCurrency

# Register AUDCurrency in _QuantLib:
_QuantLib.AUDCurrency_swigregister(AUDCurrency)
class BDTCurrency(Currency):
    r"""Proxy of C++ QuantLib::BDTCurrency class."""

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

    def __init__(self):
        r"""__init__(BDTCurrency self) -> BDTCurrency"""
        _QuantLib.BDTCurrency_swiginit(self, _QuantLib.new_BDTCurrency())
    __swig_destroy__ = _QuantLib.delete_BDTCurrency

# Register BDTCurrency in _QuantLib:
_QuantLib.BDTCurrency_swigregister(BDTCurrency)
class BEFCurrency(Currency):
    r"""Proxy of C++ QuantLib::BEFCurrency class."""

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

    def __init__(self):
        r"""__init__(BEFCurrency self) -> BEFCurrency"""
        _QuantLib.BEFCurrency_swiginit(self, _QuantLib.new_BEFCurrency())
    __swig_destroy__ = _QuantLib.delete_BEFCurrency

# Register BEFCurrency in _QuantLib:
_QuantLib.BEFCurrency_swigregister(BEFCurrency)
class BGLCurrency(Currency):
    r"""Proxy of C++ QuantLib::BGLCurrency class."""

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

    def __init__(self):
        r"""__init__(BGLCurrency self) -> BGLCurrency"""
        _QuantLib.BGLCurrency_swiginit(self, _QuantLib.new_BGLCurrency())
    __swig_destroy__ = _QuantLib.delete_BGLCurrency

# Register BGLCurrency in _QuantLib:
_QuantLib.BGLCurrency_swigregister(BGLCurrency)
class BRLCurrency(Currency):
    r"""Proxy of C++ QuantLib::BRLCurrency class."""

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

    def __init__(self):
        r"""__init__(BRLCurrency self) -> BRLCurrency"""
        _QuantLib.BRLCurrency_swiginit(self, _QuantLib.new_BRLCurrency())
    __swig_destroy__ = _QuantLib.delete_BRLCurrency

# Register BRLCurrency in _QuantLib:
_QuantLib.BRLCurrency_swigregister(BRLCurrency)
class BYRCurrency(Currency):
    r"""Proxy of C++ QuantLib::BYRCurrency class."""

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

    def __init__(self):
        r"""__init__(BYRCurrency self) -> BYRCurrency"""
        _QuantLib.BYRCurrency_swiginit(self, _QuantLib.new_BYRCurrency())
    __swig_destroy__ = _QuantLib.delete_BYRCurrency

# Register BYRCurrency in _QuantLib:
_QuantLib.BYRCurrency_swigregister(BYRCurrency)
class CADCurrency(Currency):
    r"""Proxy of C++ QuantLib::CADCurrency class."""

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

    def __init__(self):
        r"""__init__(CADCurrency self) -> CADCurrency"""
        _QuantLib.CADCurrency_swiginit(self, _QuantLib.new_CADCurrency())
    __swig_destroy__ = _QuantLib.delete_CADCurrency

# Register CADCurrency in _QuantLib:
_QuantLib.CADCurrency_swigregister(CADCurrency)
class CHFCurrency(Currency):
    r"""Proxy of C++ QuantLib::CHFCurrency class."""

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

    def __init__(self):
        r"""__init__(CHFCurrency self) -> CHFCurrency"""
        _QuantLib.CHFCurrency_swiginit(self, _QuantLib.new_CHFCurrency())
    __swig_destroy__ = _QuantLib.delete_CHFCurrency

# Register CHFCurrency in _QuantLib:
_QuantLib.CHFCurrency_swigregister(CHFCurrency)
class CLPCurrency(Currency):
    r"""Proxy of C++ QuantLib::CLPCurrency class."""

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

    def __init__(self):
        r"""__init__(CLPCurrency self) -> CLPCurrency"""
        _QuantLib.CLPCurrency_swiginit(self, _QuantLib.new_CLPCurrency())
    __swig_destroy__ = _QuantLib.delete_CLPCurrency

# Register CLPCurrency in _QuantLib:
_QuantLib.CLPCurrency_swigregister(CLPCurrency)
class CNYCurrency(Currency):
    r"""Proxy of C++ QuantLib::CNYCurrency class."""

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

    def __init__(self):
        r"""__init__(CNYCurrency self) -> CNYCurrency"""
        _QuantLib.CNYCurrency_swiginit(self, _QuantLib.new_CNYCurrency())
    __swig_destroy__ = _QuantLib.delete_CNYCurrency

# Register CNYCurrency in _QuantLib:
_QuantLib.CNYCurrency_swigregister(CNYCurrency)
class COPCurrency(Currency):
    r"""Proxy of C++ QuantLib::COPCurrency class."""

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

    def __init__(self):
        r"""__init__(COPCurrency self) -> COPCurrency"""
        _QuantLib.COPCurrency_swiginit(self, _QuantLib.new_COPCurrency())
    __swig_destroy__ = _QuantLib.delete_COPCurrency

# Register COPCurrency in _QuantLib:
_QuantLib.COPCurrency_swigregister(COPCurrency)
class CYPCurrency(Currency):
    r"""Proxy of C++ QuantLib::CYPCurrency class."""

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

    def __init__(self):
        r"""__init__(CYPCurrency self) -> CYPCurrency"""
        _QuantLib.CYPCurrency_swiginit(self, _QuantLib.new_CYPCurrency())
    __swig_destroy__ = _QuantLib.delete_CYPCurrency

# Register CYPCurrency in _QuantLib:
_QuantLib.CYPCurrency_swigregister(CYPCurrency)
class CZKCurrency(Currency):
    r"""Proxy of C++ QuantLib::CZKCurrency class."""

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

    def __init__(self):
        r"""__init__(CZKCurrency self) -> CZKCurrency"""
        _QuantLib.CZKCurrency_swiginit(self, _QuantLib.new_CZKCurrency())
    __swig_destroy__ = _QuantLib.delete_CZKCurrency

# Register CZKCurrency in _QuantLib:
_QuantLib.CZKCurrency_swigregister(CZKCurrency)
class DEMCurrency(Currency):
    r"""Proxy of C++ QuantLib::DEMCurrency class."""

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

    def __init__(self):
        r"""__init__(DEMCurrency self) -> DEMCurrency"""
        _QuantLib.DEMCurrency_swiginit(self, _QuantLib.new_DEMCurrency())
    __swig_destroy__ = _QuantLib.delete_DEMCurrency

# Register DEMCurrency in _QuantLib:
_QuantLib.DEMCurrency_swigregister(DEMCurrency)
class DKKCurrency(Currency):
    r"""Proxy of C++ QuantLib::DKKCurrency class."""

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

    def __init__(self):
        r"""__init__(DKKCurrency self) -> DKKCurrency"""
        _QuantLib.DKKCurrency_swiginit(self, _QuantLib.new_DKKCurrency())
    __swig_destroy__ = _QuantLib.delete_DKKCurrency

# Register DKKCurrency in _QuantLib:
_QuantLib.DKKCurrency_swigregister(DKKCurrency)
class EEKCurrency(Currency):
    r"""Proxy of C++ QuantLib::EEKCurrency class."""

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

    def __init__(self):
        r"""__init__(EEKCurrency self) -> EEKCurrency"""
        _QuantLib.EEKCurrency_swiginit(self, _QuantLib.new_EEKCurrency())
    __swig_destroy__ = _QuantLib.delete_EEKCurrency

# Register EEKCurrency in _QuantLib:
_QuantLib.EEKCurrency_swigregister(EEKCurrency)
class ESPCurrency(Currency):
    r"""Proxy of C++ QuantLib::ESPCurrency class."""

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

    def __init__(self):
        r"""__init__(ESPCurrency self) -> ESPCurrency"""
        _QuantLib.ESPCurrency_swiginit(self, _QuantLib.new_ESPCurrency())
    __swig_destroy__ = _QuantLib.delete_ESPCurrency

# Register ESPCurrency in _QuantLib:
_QuantLib.ESPCurrency_swigregister(ESPCurrency)
class EURCurrency(Currency):
    r"""Proxy of C++ QuantLib::EURCurrency class."""

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

    def __init__(self):
        r"""__init__(EURCurrency self) -> EURCurrency"""
        _QuantLib.EURCurrency_swiginit(self, _QuantLib.new_EURCurrency())
    __swig_destroy__ = _QuantLib.delete_EURCurrency

# Register EURCurrency in _QuantLib:
_QuantLib.EURCurrency_swigregister(EURCurrency)
class FIMCurrency(Currency):
    r"""Proxy of C++ QuantLib::FIMCurrency class."""

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

    def __init__(self):
        r"""__init__(FIMCurrency self) -> FIMCurrency"""
        _QuantLib.FIMCurrency_swiginit(self, _QuantLib.new_FIMCurrency())
    __swig_destroy__ = _QuantLib.delete_FIMCurrency

# Register FIMCurrency in _QuantLib:
_QuantLib.FIMCurrency_swigregister(FIMCurrency)
class FRFCurrency(Currency):
    r"""Proxy of C++ QuantLib::FRFCurrency class."""

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

    def __init__(self):
        r"""__init__(FRFCurrency self) -> FRFCurrency"""
        _QuantLib.FRFCurrency_swiginit(self, _QuantLib.new_FRFCurrency())
    __swig_destroy__ = _QuantLib.delete_FRFCurrency

# Register FRFCurrency in _QuantLib:
_QuantLib.FRFCurrency_swigregister(FRFCurrency)
class GBPCurrency(Currency):
    r"""Proxy of C++ QuantLib::GBPCurrency class."""

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

    def __init__(self):
        r"""__init__(GBPCurrency self) -> GBPCurrency"""
        _QuantLib.GBPCurrency_swiginit(self, _QuantLib.new_GBPCurrency())
    __swig_destroy__ = _QuantLib.delete_GBPCurrency

# Register GBPCurrency in _QuantLib:
_QuantLib.GBPCurrency_swigregister(GBPCurrency)
class GRDCurrency(Currency):
    r"""Proxy of C++ QuantLib::GRDCurrency class."""

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

    def __init__(self):
        r"""__init__(GRDCurrency self) -> GRDCurrency"""
        _QuantLib.GRDCurrency_swiginit(self, _QuantLib.new_GRDCurrency())
    __swig_destroy__ = _QuantLib.delete_GRDCurrency

# Register GRDCurrency in _QuantLib:
_QuantLib.GRDCurrency_swigregister(GRDCurrency)
class HKDCurrency(Currency):
    r"""Proxy of C++ QuantLib::HKDCurrency class."""

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

    def __init__(self):
        r"""__init__(HKDCurrency self) -> HKDCurrency"""
        _QuantLib.HKDCurrency_swiginit(self, _QuantLib.new_HKDCurrency())
    __swig_destroy__ = _QuantLib.delete_HKDCurrency

# Register HKDCurrency in _QuantLib:
_QuantLib.HKDCurrency_swigregister(HKDCurrency)
class HUFCurrency(Currency):
    r"""Proxy of C++ QuantLib::HUFCurrency class."""

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

    def __init__(self):
        r"""__init__(HUFCurrency self) -> HUFCurrency"""
        _QuantLib.HUFCurrency_swiginit(self, _QuantLib.new_HUFCurrency())
    __swig_destroy__ = _QuantLib.delete_HUFCurrency

# Register HUFCurrency in _QuantLib:
_QuantLib.HUFCurrency_swigregister(HUFCurrency)
class IEPCurrency(Currency):
    r"""Proxy of C++ QuantLib::IEPCurrency class."""

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

    def __init__(self):
        r"""__init__(IEPCurrency self) -> IEPCurrency"""
        _QuantLib.IEPCurrency_swiginit(self, _QuantLib.new_IEPCurrency())
    __swig_destroy__ = _QuantLib.delete_IEPCurrency

# Register IEPCurrency in _QuantLib:
_QuantLib.IEPCurrency_swigregister(IEPCurrency)
class IDRCurrency(Currency):
    r"""Proxy of C++ QuantLib::IDRCurrency class."""

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

    def __init__(self):
        r"""__init__(IDRCurrency self) -> IDRCurrency"""
        _QuantLib.IDRCurrency_swiginit(self, _QuantLib.new_IDRCurrency())
    __swig_destroy__ = _QuantLib.delete_IDRCurrency

# Register IDRCurrency in _QuantLib:
_QuantLib.IDRCurrency_swigregister(IDRCurrency)
class ILSCurrency(Currency):
    r"""Proxy of C++ QuantLib::ILSCurrency class."""

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

    def __init__(self):
        r"""__init__(ILSCurrency self) -> ILSCurrency"""
        _QuantLib.ILSCurrency_swiginit(self, _QuantLib.new_ILSCurrency())
    __swig_destroy__ = _QuantLib.delete_ILSCurrency

# Register ILSCurrency in _QuantLib:
_QuantLib.ILSCurrency_swigregister(ILSCurrency)
class INRCurrency(Currency):
    r"""Proxy of C++ QuantLib::INRCurrency class."""

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

    def __init__(self):
        r"""__init__(INRCurrency self) -> INRCurrency"""
        _QuantLib.INRCurrency_swiginit(self, _QuantLib.new_INRCurrency())
    __swig_destroy__ = _QuantLib.delete_INRCurrency

# Register INRCurrency in _QuantLib:
_QuantLib.INRCurrency_swigregister(INRCurrency)
class IQDCurrency(Currency):
    r"""Proxy of C++ QuantLib::IQDCurrency class."""

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

    def __init__(self):
        r"""__init__(IQDCurrency self) -> IQDCurrency"""
        _QuantLib.IQDCurrency_swiginit(self, _QuantLib.new_IQDCurrency())
    __swig_destroy__ = _QuantLib.delete_IQDCurrency

# Register IQDCurrency in _QuantLib:
_QuantLib.IQDCurrency_swigregister(IQDCurrency)
class IRRCurrency(Currency):
    r"""Proxy of C++ QuantLib::IRRCurrency class."""

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

    def __init__(self):
        r"""__init__(IRRCurrency self) -> IRRCurrency"""
        _QuantLib.IRRCurrency_swiginit(self, _QuantLib.new_IRRCurrency())
    __swig_destroy__ = _QuantLib.delete_IRRCurrency

# Register IRRCurrency in _QuantLib:
_QuantLib.IRRCurrency_swigregister(IRRCurrency)
class ISKCurrency(Currency):
    r"""Proxy of C++ QuantLib::ISKCurrency class."""

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

    def __init__(self):
        r"""__init__(ISKCurrency self) -> ISKCurrency"""
        _QuantLib.ISKCurrency_swiginit(self, _QuantLib.new_ISKCurrency())
    __swig_destroy__ = _QuantLib.delete_ISKCurrency

# Register ISKCurrency in _QuantLib:
_QuantLib.ISKCurrency_swigregister(ISKCurrency)
class ITLCurrency(Currency):
    r"""Proxy of C++ QuantLib::ITLCurrency class."""

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

    def __init__(self):
        r"""__init__(ITLCurrency self) -> ITLCurrency"""
        _QuantLib.ITLCurrency_swiginit(self, _QuantLib.new_ITLCurrency())
    __swig_destroy__ = _QuantLib.delete_ITLCurrency

# Register ITLCurrency in _QuantLib:
_QuantLib.ITLCurrency_swigregister(ITLCurrency)
class JPYCurrency(Currency):
    r"""Proxy of C++ QuantLib::JPYCurrency class."""

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

    def __init__(self):
        r"""__init__(JPYCurrency self) -> JPYCurrency"""
        _QuantLib.JPYCurrency_swiginit(self, _QuantLib.new_JPYCurrency())
    __swig_destroy__ = _QuantLib.delete_JPYCurrency

# Register JPYCurrency in _QuantLib:
_QuantLib.JPYCurrency_swigregister(JPYCurrency)
class KRWCurrency(Currency):
    r"""Proxy of C++ QuantLib::KRWCurrency class."""

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

    def __init__(self):
        r"""__init__(KRWCurrency self) -> KRWCurrency"""
        _QuantLib.KRWCurrency_swiginit(self, _QuantLib.new_KRWCurrency())
    __swig_destroy__ = _QuantLib.delete_KRWCurrency

# Register KRWCurrency in _QuantLib:
_QuantLib.KRWCurrency_swigregister(KRWCurrency)
class KWDCurrency(Currency):
    r"""Proxy of C++ QuantLib::KWDCurrency class."""

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

    def __init__(self):
        r"""__init__(KWDCurrency self) -> KWDCurrency"""
        _QuantLib.KWDCurrency_swiginit(self, _QuantLib.new_KWDCurrency())
    __swig_destroy__ = _QuantLib.delete_KWDCurrency

# Register KWDCurrency in _QuantLib:
_QuantLib.KWDCurrency_swigregister(KWDCurrency)
class LTLCurrency(Currency):
    r"""Proxy of C++ QuantLib::LTLCurrency class."""

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

    def __init__(self):
        r"""__init__(LTLCurrency self) -> LTLCurrency"""
        _QuantLib.LTLCurrency_swiginit(self, _QuantLib.new_LTLCurrency())
    __swig_destroy__ = _QuantLib.delete_LTLCurrency

# Register LTLCurrency in _QuantLib:
_QuantLib.LTLCurrency_swigregister(LTLCurrency)
class LUFCurrency(Currency):
    r"""Proxy of C++ QuantLib::LUFCurrency class."""

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

    def __init__(self):
        r"""__init__(LUFCurrency self) -> LUFCurrency"""
        _QuantLib.LUFCurrency_swiginit(self, _QuantLib.new_LUFCurrency())
    __swig_destroy__ = _QuantLib.delete_LUFCurrency

# Register LUFCurrency in _QuantLib:
_QuantLib.LUFCurrency_swigregister(LUFCurrency)
class LVLCurrency(Currency):
    r"""Proxy of C++ QuantLib::LVLCurrency class."""

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

    def __init__(self):
        r"""__init__(LVLCurrency self) -> LVLCurrency"""
        _QuantLib.LVLCurrency_swiginit(self, _QuantLib.new_LVLCurrency())
    __swig_destroy__ = _QuantLib.delete_LVLCurrency

# Register LVLCurrency in _QuantLib:
_QuantLib.LVLCurrency_swigregister(LVLCurrency)
class MTLCurrency(Currency):
    r"""Proxy of C++ QuantLib::MTLCurrency class."""

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

    def __init__(self):
        r"""__init__(MTLCurrency self) -> MTLCurrency"""
        _QuantLib.MTLCurrency_swiginit(self, _QuantLib.new_MTLCurrency())
    __swig_destroy__ = _QuantLib.delete_MTLCurrency

# Register MTLCurrency in _QuantLib:
_QuantLib.MTLCurrency_swigregister(MTLCurrency)
class MXNCurrency(Currency):
    r"""Proxy of C++ QuantLib::MXNCurrency class."""

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

    def __init__(self):
        r"""__init__(MXNCurrency self) -> MXNCurrency"""
        _QuantLib.MXNCurrency_swiginit(self, _QuantLib.new_MXNCurrency())
    __swig_destroy__ = _QuantLib.delete_MXNCurrency

# Register MXNCurrency in _QuantLib:
_QuantLib.MXNCurrency_swigregister(MXNCurrency)
class MYRCurrency(Currency):
    r"""Proxy of C++ QuantLib::MYRCurrency class."""

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

    def __init__(self):
        r"""__init__(MYRCurrency self) -> MYRCurrency"""
        _QuantLib.MYRCurrency_swiginit(self, _QuantLib.new_MYRCurrency())
    __swig_destroy__ = _QuantLib.delete_MYRCurrency

# Register MYRCurrency in _QuantLib:
_QuantLib.MYRCurrency_swigregister(MYRCurrency)
class NLGCurrency(Currency):
    r"""Proxy of C++ QuantLib::NLGCurrency class."""

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

    def __init__(self):
        r"""__init__(NLGCurrency self) -> NLGCurrency"""
        _QuantLib.NLGCurrency_swiginit(self, _QuantLib.new_NLGCurrency())
    __swig_destroy__ = _QuantLib.delete_NLGCurrency

# Register NLGCurrency in _QuantLib:
_QuantLib.NLGCurrency_swigregister(NLGCurrency)
class NOKCurrency(Currency):
    r"""Proxy of C++ QuantLib::NOKCurrency class."""

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

    def __init__(self):
        r"""__init__(NOKCurrency self) -> NOKCurrency"""
        _QuantLib.NOKCurrency_swiginit(self, _QuantLib.new_NOKCurrency())
    __swig_destroy__ = _QuantLib.delete_NOKCurrency

# Register NOKCurrency in _QuantLib:
_QuantLib.NOKCurrency_swigregister(NOKCurrency)
class NPRCurrency(Currency):
    r"""Proxy of C++ QuantLib::NPRCurrency class."""

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

    def __init__(self):
        r"""__init__(NPRCurrency self) -> NPRCurrency"""
        _QuantLib.NPRCurrency_swiginit(self, _QuantLib.new_NPRCurrency())
    __swig_destroy__ = _QuantLib.delete_NPRCurrency

# Register NPRCurrency in _QuantLib:
_QuantLib.NPRCurrency_swigregister(NPRCurrency)
class NZDCurrency(Currency):
    r"""Proxy of C++ QuantLib::NZDCurrency class."""

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

    def __init__(self):
        r"""__init__(NZDCurrency self) -> NZDCurrency"""
        _QuantLib.NZDCurrency_swiginit(self, _QuantLib.new_NZDCurrency())
    __swig_destroy__ = _QuantLib.delete_NZDCurrency

# Register NZDCurrency in _QuantLib:
_QuantLib.NZDCurrency_swigregister(NZDCurrency)
class PEHCurrency(Currency):
    r"""Proxy of C++ QuantLib::PEHCurrency class."""

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

    def __init__(self):
        r"""__init__(PEHCurrency self) -> PEHCurrency"""
        _QuantLib.PEHCurrency_swiginit(self, _QuantLib.new_PEHCurrency())
    __swig_destroy__ = _QuantLib.delete_PEHCurrency

# Register PEHCurrency in _QuantLib:
_QuantLib.PEHCurrency_swigregister(PEHCurrency)
class PEICurrency(Currency):
    r"""Proxy of C++ QuantLib::PEICurrency class."""

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

    def __init__(self):
        r"""__init__(PEICurrency self) -> PEICurrency"""
        _QuantLib.PEICurrency_swiginit(self, _QuantLib.new_PEICurrency())
    __swig_destroy__ = _QuantLib.delete_PEICurrency

# Register PEICurrency in _QuantLib:
_QuantLib.PEICurrency_swigregister(PEICurrency)
class PENCurrency(Currency):
    r"""Proxy of C++ QuantLib::PENCurrency class."""

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

    def __init__(self):
        r"""__init__(PENCurrency self) -> PENCurrency"""
        _QuantLib.PENCurrency_swiginit(self, _QuantLib.new_PENCurrency())
    __swig_destroy__ = _QuantLib.delete_PENCurrency

# Register PENCurrency in _QuantLib:
_QuantLib.PENCurrency_swigregister(PENCurrency)
class PKRCurrency(Currency):
    r"""Proxy of C++ QuantLib::PKRCurrency class."""

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

    def __init__(self):
        r"""__init__(PKRCurrency self) -> PKRCurrency"""
        _QuantLib.PKRCurrency_swiginit(self, _QuantLib.new_PKRCurrency())
    __swig_destroy__ = _QuantLib.delete_PKRCurrency

# Register PKRCurrency in _QuantLib:
_QuantLib.PKRCurrency_swigregister(PKRCurrency)
class PLNCurrency(Currency):
    r"""Proxy of C++ QuantLib::PLNCurrency class."""

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

    def __init__(self):
        r"""__init__(PLNCurrency self) -> PLNCurrency"""
        _QuantLib.PLNCurrency_swiginit(self, _QuantLib.new_PLNCurrency())
    __swig_destroy__ = _QuantLib.delete_PLNCurrency

# Register PLNCurrency in _QuantLib:
_QuantLib.PLNCurrency_swigregister(PLNCurrency)
class PTECurrency(Currency):
    r"""Proxy of C++ QuantLib::PTECurrency class."""

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

    def __init__(self):
        r"""__init__(PTECurrency self) -> PTECurrency"""
        _QuantLib.PTECurrency_swiginit(self, _QuantLib.new_PTECurrency())
    __swig_destroy__ = _QuantLib.delete_PTECurrency

# Register PTECurrency in _QuantLib:
_QuantLib.PTECurrency_swigregister(PTECurrency)
class ROLCurrency(Currency):
    r"""Proxy of C++ QuantLib::ROLCurrency class."""

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

    def __init__(self):
        r"""__init__(ROLCurrency self) -> ROLCurrency"""
        _QuantLib.ROLCurrency_swiginit(self, _QuantLib.new_ROLCurrency())
    __swig_destroy__ = _QuantLib.delete_ROLCurrency

# Register ROLCurrency in _QuantLib:
_QuantLib.ROLCurrency_swigregister(ROLCurrency)
class RONCurrency(Currency):
    r"""Proxy of C++ QuantLib::RONCurrency class."""

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

    def __init__(self):
        r"""__init__(RONCurrency self) -> RONCurrency"""
        _QuantLib.RONCurrency_swiginit(self, _QuantLib.new_RONCurrency())
    __swig_destroy__ = _QuantLib.delete_RONCurrency

# Register RONCurrency in _QuantLib:
_QuantLib.RONCurrency_swigregister(RONCurrency)
class RUBCurrency(Currency):
    r"""Proxy of C++ QuantLib::RUBCurrency class."""

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

    def __init__(self):
        r"""__init__(RUBCurrency self) -> RUBCurrency"""
        _QuantLib.RUBCurrency_swiginit(self, _QuantLib.new_RUBCurrency())
    __swig_destroy__ = _QuantLib.delete_RUBCurrency

# Register RUBCurrency in _QuantLib:
_QuantLib.RUBCurrency_swigregister(RUBCurrency)
class SARCurrency(Currency):
    r"""Proxy of C++ QuantLib::SARCurrency class."""

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

    def __init__(self):
        r"""__init__(SARCurrency self) -> SARCurrency"""
        _QuantLib.SARCurrency_swiginit(self, _QuantLib.new_SARCurrency())
    __swig_destroy__ = _QuantLib.delete_SARCurrency

# Register SARCurrency in _QuantLib:
_QuantLib.SARCurrency_swigregister(SARCurrency)
class SEKCurrency(Currency):
    r"""Proxy of C++ QuantLib::SEKCurrency class."""

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

    def __init__(self):
        r"""__init__(SEKCurrency self) -> SEKCurrency"""
        _QuantLib.SEKCurrency_swiginit(self, _QuantLib.new_SEKCurrency())
    __swig_destroy__ = _QuantLib.delete_SEKCurrency

# Register SEKCurrency in _QuantLib:
_QuantLib.SEKCurrency_swigregister(SEKCurrency)
class SGDCurrency(Currency):
    r"""Proxy of C++ QuantLib::SGDCurrency class."""

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

    def __init__(self):
        r"""__init__(SGDCurrency self) -> SGDCurrency"""
        _QuantLib.SGDCurrency_swiginit(self, _QuantLib.new_SGDCurrency())
    __swig_destroy__ = _QuantLib.delete_SGDCurrency

# Register SGDCurrency in _QuantLib:
_QuantLib.SGDCurrency_swigregister(SGDCurrency)
class SITCurrency(Currency):
    r"""Proxy of C++ QuantLib::SITCurrency class."""

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

    def __init__(self):
        r"""__init__(SITCurrency self) -> SITCurrency"""
        _QuantLib.SITCurrency_swiginit(self, _QuantLib.new_SITCurrency())
    __swig_destroy__ = _QuantLib.delete_SITCurrency

# Register SITCurrency in _QuantLib:
_QuantLib.SITCurrency_swigregister(SITCurrency)
class SKKCurrency(Currency):
    r"""Proxy of C++ QuantLib::SKKCurrency class."""

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

    def __init__(self):
        r"""__init__(SKKCurrency self) -> SKKCurrency"""
        _QuantLib.SKKCurrency_swiginit(self, _QuantLib.new_SKKCurrency())
    __swig_destroy__ = _QuantLib.delete_SKKCurrency

# Register SKKCurrency in _QuantLib:
_QuantLib.SKKCurrency_swigregister(SKKCurrency)
class THBCurrency(Currency):
    r"""Proxy of C++ QuantLib::THBCurrency class."""

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

    def __init__(self):
        r"""__init__(THBCurrency self) -> THBCurrency"""
        _QuantLib.THBCurrency_swiginit(self, _QuantLib.new_THBCurrency())
    __swig_destroy__ = _QuantLib.delete_THBCurrency

# Register THBCurrency in _QuantLib:
_QuantLib.THBCurrency_swigregister(THBCurrency)
class TRLCurrency(Currency):
    r"""Proxy of C++ QuantLib::TRLCurrency class."""

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

    def __init__(self):
        r"""__init__(TRLCurrency self) -> TRLCurrency"""
        _QuantLib.TRLCurrency_swiginit(self, _QuantLib.new_TRLCurrency())
    __swig_destroy__ = _QuantLib.delete_TRLCurrency

# Register TRLCurrency in _QuantLib:
_QuantLib.TRLCurrency_swigregister(TRLCurrency)
class TRYCurrency(Currency):
    r"""Proxy of C++ QuantLib::TRYCurrency class."""

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

    def __init__(self):
        r"""__init__(TRYCurrency self) -> TRYCurrency"""
        _QuantLib.TRYCurrency_swiginit(self, _QuantLib.new_TRYCurrency())
    __swig_destroy__ = _QuantLib.delete_TRYCurrency

# Register TRYCurrency in _QuantLib:
_QuantLib.TRYCurrency_swigregister(TRYCurrency)
class TTDCurrency(Currency):
    r"""Proxy of C++ QuantLib::TTDCurrency class."""

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

    def __init__(self):
        r"""__init__(TTDCurrency self) -> TTDCurrency"""
        _QuantLib.TTDCurrency_swiginit(self, _QuantLib.new_TTDCurrency())
    __swig_destroy__ = _QuantLib.delete_TTDCurrency

# Register TTDCurrency in _QuantLib:
_QuantLib.TTDCurrency_swigregister(TTDCurrency)
class TWDCurrency(Currency):
    r"""Proxy of C++ QuantLib::TWDCurrency class."""

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

    def __init__(self):
        r"""__init__(TWDCurrency self) -> TWDCurrency"""
        _QuantLib.TWDCurrency_swiginit(self, _QuantLib.new_TWDCurrency())
    __swig_destroy__ = _QuantLib.delete_TWDCurrency

# Register TWDCurrency in _QuantLib:
_QuantLib.TWDCurrency_swigregister(TWDCurrency)
class USDCurrency(Currency):
    r"""Proxy of C++ QuantLib::USDCurrency class."""

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

    def __init__(self):
        r"""__init__(USDCurrency self) -> USDCurrency"""
        _QuantLib.USDCurrency_swiginit(self, _QuantLib.new_USDCurrency())
    __swig_destroy__ = _QuantLib.delete_USDCurrency

# Register USDCurrency in _QuantLib:
_QuantLib.USDCurrency_swigregister(USDCurrency)
class VEBCurrency(Currency):
    r"""Proxy of C++ QuantLib::VEBCurrency class."""

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

    def __init__(self):
        r"""__init__(VEBCurrency self) -> VEBCurrency"""
        _QuantLib.VEBCurrency_swiginit(self, _QuantLib.new_VEBCurrency())
    __swig_destroy__ = _QuantLib.delete_VEBCurrency

# Register VEBCurrency in _QuantLib:
_QuantLib.VEBCurrency_swigregister(VEBCurrency)
class VNDCurrency(Currency):
    r"""Proxy of C++ QuantLib::VNDCurrency class."""

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

    def __init__(self):
        r"""__init__(VNDCurrency self) -> VNDCurrency"""
        _QuantLib.VNDCurrency_swiginit(self, _QuantLib.new_VNDCurrency())
    __swig_destroy__ = _QuantLib.delete_VNDCurrency

# Register VNDCurrency in _QuantLib:
_QuantLib.VNDCurrency_swigregister(VNDCurrency)
class ZARCurrency(Currency):
    r"""Proxy of C++ QuantLib::ZARCurrency class."""

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

    def __init__(self):
        r"""__init__(ZARCurrency self) -> ZARCurrency"""
        _QuantLib.ZARCurrency_swiginit(self, _QuantLib.new_ZARCurrency())
    __swig_destroy__ = _QuantLib.delete_ZARCurrency

# Register ZARCurrency in _QuantLib:
_QuantLib.ZARCurrency_swigregister(ZARCurrency)
class Brent(object):
    r"""Proxy of C++ Brent class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(Brent self, Size evaluations)"""
        return _QuantLib.Brent_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(Brent self, Real lowerBound)"""
        return _QuantLib.Brent_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(Brent self, Real upperBound)"""
        return _QuantLib.Brent_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(Brent self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(Brent self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.Brent_solve(self, *args)

    def __init__(self):
        r"""__init__(Brent self) -> Brent"""
        _QuantLib.Brent_swiginit(self, _QuantLib.new_Brent())
    __swig_destroy__ = _QuantLib.delete_Brent

# Register Brent in _QuantLib:
_QuantLib.Brent_swigregister(Brent)
class Bisection(object):
    r"""Proxy of C++ Bisection class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(Bisection self, Size evaluations)"""
        return _QuantLib.Bisection_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(Bisection self, Real lowerBound)"""
        return _QuantLib.Bisection_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(Bisection self, Real upperBound)"""
        return _QuantLib.Bisection_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(Bisection self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(Bisection self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.Bisection_solve(self, *args)

    def __init__(self):
        r"""__init__(Bisection self) -> Bisection"""
        _QuantLib.Bisection_swiginit(self, _QuantLib.new_Bisection())
    __swig_destroy__ = _QuantLib.delete_Bisection

# Register Bisection in _QuantLib:
_QuantLib.Bisection_swigregister(Bisection)
class FalsePosition(object):
    r"""Proxy of C++ FalsePosition class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(FalsePosition self, Size evaluations)"""
        return _QuantLib.FalsePosition_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(FalsePosition self, Real lowerBound)"""
        return _QuantLib.FalsePosition_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(FalsePosition self, Real upperBound)"""
        return _QuantLib.FalsePosition_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(FalsePosition self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(FalsePosition self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.FalsePosition_solve(self, *args)

    def __init__(self):
        r"""__init__(FalsePosition self) -> FalsePosition"""
        _QuantLib.FalsePosition_swiginit(self, _QuantLib.new_FalsePosition())
    __swig_destroy__ = _QuantLib.delete_FalsePosition

# Register FalsePosition in _QuantLib:
_QuantLib.FalsePosition_swigregister(FalsePosition)
class Ridder(object):
    r"""Proxy of C++ Ridder class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(Ridder self, Size evaluations)"""
        return _QuantLib.Ridder_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(Ridder self, Real lowerBound)"""
        return _QuantLib.Ridder_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(Ridder self, Real upperBound)"""
        return _QuantLib.Ridder_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(Ridder self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(Ridder self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.Ridder_solve(self, *args)

    def __init__(self):
        r"""__init__(Ridder self) -> Ridder"""
        _QuantLib.Ridder_swiginit(self, _QuantLib.new_Ridder())
    __swig_destroy__ = _QuantLib.delete_Ridder

# Register Ridder in _QuantLib:
_QuantLib.Ridder_swigregister(Ridder)
class Secant(object):
    r"""Proxy of C++ Secant class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(Secant self, Size evaluations)"""
        return _QuantLib.Secant_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(Secant self, Real lowerBound)"""
        return _QuantLib.Secant_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(Secant self, Real upperBound)"""
        return _QuantLib.Secant_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(Secant self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(Secant self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.Secant_solve(self, *args)

    def __init__(self):
        r"""__init__(Secant self) -> Secant"""
        _QuantLib.Secant_swiginit(self, _QuantLib.new_Secant())
    __swig_destroy__ = _QuantLib.delete_Secant

# Register Secant in _QuantLib:
_QuantLib.Secant_swigregister(Secant)
class Newton(object):
    r"""Proxy of C++ Newton class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(Newton self, Size evaluations)"""
        return _QuantLib.Newton_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(Newton self, Real lowerBound)"""
        return _QuantLib.Newton_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(Newton self, Real upperBound)"""
        return _QuantLib.Newton_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(Newton self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(Newton self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.Newton_solve(self, *args)

    def __init__(self):
        r"""__init__(Newton self) -> Newton"""
        _QuantLib.Newton_swiginit(self, _QuantLib.new_Newton())
    __swig_destroy__ = _QuantLib.delete_Newton

# Register Newton in _QuantLib:
_QuantLib.Newton_swigregister(Newton)
class NewtonSafe(object):
    r"""Proxy of C++ NewtonSafe class."""

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

    def setMaxEvaluations(self, evaluations):
        r"""setMaxEvaluations(NewtonSafe self, Size evaluations)"""
        return _QuantLib.NewtonSafe_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        r"""setLowerBound(NewtonSafe self, Real lowerBound)"""
        return _QuantLib.NewtonSafe_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        r"""setUpperBound(NewtonSafe self, Real upperBound)"""
        return _QuantLib.NewtonSafe_setUpperBound(self, upperBound)

    def solve(self, *args):
        r"""
        solve(NewtonSafe self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real
        solve(NewtonSafe self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real
        """
        return _QuantLib.NewtonSafe_solve(self, *args)

    def __init__(self):
        r"""__init__(NewtonSafe self) -> NewtonSafe"""
        _QuantLib.NewtonSafe_swiginit(self, _QuantLib.new_NewtonSafe())
    __swig_destroy__ = _QuantLib.delete_NewtonSafe

# Register NewtonSafe in _QuantLib:
_QuantLib.NewtonSafe_swigregister(NewtonSafe)
class Constraint(object):
    r"""Proxy of C++ Constraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register Constraint in _QuantLib:
_QuantLib.Constraint_swigregister(Constraint)
class BoundaryConstraint(Constraint):
    r"""Proxy of C++ BoundaryConstraint class."""

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

    def __init__(self, lower, upper):
        r"""__init__(BoundaryConstraint self, Real lower, Real upper) -> BoundaryConstraint"""
        _QuantLib.BoundaryConstraint_swiginit(self, _QuantLib.new_BoundaryConstraint(lower, upper))
    __swig_destroy__ = _QuantLib.delete_BoundaryConstraint

# Register BoundaryConstraint in _QuantLib:
_QuantLib.BoundaryConstraint_swigregister(BoundaryConstraint)
class NoConstraint(Constraint):
    r"""Proxy of C++ NoConstraint class."""

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

    def __init__(self):
        r"""__init__(NoConstraint self) -> NoConstraint"""
        _QuantLib.NoConstraint_swiginit(self, _QuantLib.new_NoConstraint())
    __swig_destroy__ = _QuantLib.delete_NoConstraint

# Register NoConstraint in _QuantLib:
_QuantLib.NoConstraint_swigregister(NoConstraint)
class PositiveConstraint(Constraint):
    r"""Proxy of C++ PositiveConstraint class."""

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

    def __init__(self):
        r"""__init__(PositiveConstraint self) -> PositiveConstraint"""
        _QuantLib.PositiveConstraint_swiginit(self, _QuantLib.new_PositiveConstraint())
    __swig_destroy__ = _QuantLib.delete_PositiveConstraint

# Register PositiveConstraint in _QuantLib:
_QuantLib.PositiveConstraint_swigregister(PositiveConstraint)
class CompositeConstraint(Constraint):
    r"""Proxy of C++ CompositeConstraint class."""

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

    def __init__(self, c1, c2):
        r"""__init__(CompositeConstraint self, Constraint c1, Constraint c2) -> CompositeConstraint"""
        _QuantLib.CompositeConstraint_swiginit(self, _QuantLib.new_CompositeConstraint(c1, c2))
    __swig_destroy__ = _QuantLib.delete_CompositeConstraint

# Register CompositeConstraint in _QuantLib:
_QuantLib.CompositeConstraint_swigregister(CompositeConstraint)
class NonhomogeneousBoundaryConstraint(Constraint):
    r"""Proxy of C++ NonhomogeneousBoundaryConstraint class."""

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

    def __init__(self, l, u):
        r"""__init__(NonhomogeneousBoundaryConstraint self, Array l, Array u) -> NonhomogeneousBoundaryConstraint"""
        _QuantLib.NonhomogeneousBoundaryConstraint_swiginit(self, _QuantLib.new_NonhomogeneousBoundaryConstraint(l, u))
    __swig_destroy__ = _QuantLib.delete_NonhomogeneousBoundaryConstraint

# Register NonhomogeneousBoundaryConstraint in _QuantLib:
_QuantLib.NonhomogeneousBoundaryConstraint_swigregister(NonhomogeneousBoundaryConstraint)
class EndCriteria(object):
    r"""Proxy of C++ EndCriteria class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoCriteria = _QuantLib.EndCriteria_NoCriteria
    
    MaxIterations = _QuantLib.EndCriteria_MaxIterations
    
    StationaryPoint = _QuantLib.EndCriteria_StationaryPoint
    
    StationaryFunctionValue = _QuantLib.EndCriteria_StationaryFunctionValue
    
    StationaryFunctionAccuracy = _QuantLib.EndCriteria_StationaryFunctionAccuracy
    
    ZeroGradientNorm = _QuantLib.EndCriteria_ZeroGradientNorm
    
    Unknown = _QuantLib.EndCriteria_Unknown
    

    def __init__(self, maxIteration, maxStationaryStateIterations, rootEpsilon, functionEpsilon, gradientNormEpsilon):
        r"""__init__(EndCriteria self, Size maxIteration, Size maxStationaryStateIterations, Real rootEpsilon, Real functionEpsilon, Real gradientNormEpsilon) -> EndCriteria"""
        _QuantLib.EndCriteria_swiginit(self, _QuantLib.new_EndCriteria(maxIteration, maxStationaryStateIterations, rootEpsilon, functionEpsilon, gradientNormEpsilon))

    def __call__(self, iteration, statState, positiveOptimization, fold, normgold, fnew, normgnewx, ecType):
        r"""__call__(EndCriteria self, Size iteration, Size & statState, bool const positiveOptimization, Real const fold, Real const normgold, Real const fnew, Real const normgnewx, EndCriteria::Type & ecType) -> bool"""
        return _QuantLib.EndCriteria___call__(self, iteration, statState, positiveOptimization, fold, normgold, fnew, normgnewx, ecType)
    __swig_destroy__ = _QuantLib.delete_EndCriteria

# Register EndCriteria in _QuantLib:
_QuantLib.EndCriteria_swigregister(EndCriteria)
class OptimizationMethod(object):
    r"""Proxy of C++ OptimizationMethod class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register OptimizationMethod in _QuantLib:
_QuantLib.OptimizationMethod_swigregister(OptimizationMethod)
class ConjugateGradient(OptimizationMethod):
    r"""Proxy of C++ ConjugateGradient class."""

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

    def __init__(self):
        r"""__init__(ConjugateGradient self) -> ConjugateGradient"""
        _QuantLib.ConjugateGradient_swiginit(self, _QuantLib.new_ConjugateGradient())
    __swig_destroy__ = _QuantLib.delete_ConjugateGradient

# Register ConjugateGradient in _QuantLib:
_QuantLib.ConjugateGradient_swigregister(ConjugateGradient)
class Simplex(OptimizationMethod):
    r"""Proxy of C++ Simplex class."""

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

    def __init__(self, lambda_parameter):
        r"""__init__(Simplex self, Real lambda_parameter) -> Simplex"""
        _QuantLib.Simplex_swiginit(self, _QuantLib.new_Simplex(lambda_parameter))

    def getLambda(self):
        r"""getLambda(Simplex self) -> Real"""
        return _QuantLib.Simplex_getLambda(self)
    __swig_destroy__ = _QuantLib.delete_Simplex

# Register Simplex in _QuantLib:
_QuantLib.Simplex_swigregister(Simplex)
class SteepestDescent(OptimizationMethod):
    r"""Proxy of C++ SteepestDescent class."""

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

    def __init__(self):
        r"""__init__(SteepestDescent self) -> SteepestDescent"""
        _QuantLib.SteepestDescent_swiginit(self, _QuantLib.new_SteepestDescent())
    __swig_destroy__ = _QuantLib.delete_SteepestDescent

# Register SteepestDescent in _QuantLib:
_QuantLib.SteepestDescent_swigregister(SteepestDescent)
class BFGS(OptimizationMethod):
    r"""Proxy of C++ BFGS class."""

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

    def __init__(self):
        r"""__init__(BFGS self) -> BFGS"""
        _QuantLib.BFGS_swiginit(self, _QuantLib.new_BFGS())
    __swig_destroy__ = _QuantLib.delete_BFGS

# Register BFGS in _QuantLib:
_QuantLib.BFGS_swigregister(BFGS)
class LevenbergMarquardt(OptimizationMethod):
    r"""Proxy of C++ LevenbergMarquardt class."""

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

    def __init__(self, epsfcn=1.0e-8, xtol=1.0e-8, gtol=1.0e-8, useCostFunctionsJacobian=False):
        r"""__init__(LevenbergMarquardt self, Real epsfcn=1.0e-8, Real xtol=1.0e-8, Real gtol=1.0e-8, bool useCostFunctionsJacobian=False) -> LevenbergMarquardt"""
        _QuantLib.LevenbergMarquardt_swiginit(self, _QuantLib.new_LevenbergMarquardt(epsfcn, xtol, gtol, useCostFunctionsJacobian))
    __swig_destroy__ = _QuantLib.delete_LevenbergMarquardt

# Register LevenbergMarquardt in _QuantLib:
_QuantLib.LevenbergMarquardt_swigregister(LevenbergMarquardt)
class DifferentialEvolution(OptimizationMethod):
    r"""Proxy of C++ DifferentialEvolution class."""

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

    def __init__(self):
        r"""__init__(DifferentialEvolution self) -> DifferentialEvolution"""
        _QuantLib.DifferentialEvolution_swiginit(self, _QuantLib.new_DifferentialEvolution())
    __swig_destroy__ = _QuantLib.delete_DifferentialEvolution

# Register DifferentialEvolution in _QuantLib:
_QuantLib.DifferentialEvolution_swigregister(DifferentialEvolution)
class SamplerGaussian(object):
    r"""Proxy of C++ SamplerGaussian class."""

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

    def __init__(self, seed=0):
        r"""__init__(SamplerGaussian self, unsigned long seed=0) -> SamplerGaussian"""
        _QuantLib.SamplerGaussian_swiginit(self, _QuantLib.new_SamplerGaussian(seed))
    __swig_destroy__ = _QuantLib.delete_SamplerGaussian

# Register SamplerGaussian in _QuantLib:
_QuantLib.SamplerGaussian_swigregister(SamplerGaussian)
class SamplerLogNormal(object):
    r"""Proxy of C++ SamplerLogNormal class."""

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

    def __init__(self, seed=0):
        r"""__init__(SamplerLogNormal self, unsigned long seed=0) -> SamplerLogNormal"""
        _QuantLib.SamplerLogNormal_swiginit(self, _QuantLib.new_SamplerLogNormal(seed))
    __swig_destroy__ = _QuantLib.delete_SamplerLogNormal

# Register SamplerLogNormal in _QuantLib:
_QuantLib.SamplerLogNormal_swigregister(SamplerLogNormal)
class SamplerMirrorGaussian(object):
    r"""Proxy of C++ SamplerMirrorGaussian class."""

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

    def __init__(self, lower, upper, seed=0):
        r"""__init__(SamplerMirrorGaussian self, Array lower, Array upper, unsigned long seed=0) -> SamplerMirrorGaussian"""
        _QuantLib.SamplerMirrorGaussian_swiginit(self, _QuantLib.new_SamplerMirrorGaussian(lower, upper, seed))
    __swig_destroy__ = _QuantLib.delete_SamplerMirrorGaussian

# Register SamplerMirrorGaussian in _QuantLib:
_QuantLib.SamplerMirrorGaussian_swigregister(SamplerMirrorGaussian)
class ProbabilityBoltzmannDownhill(object):
    r"""Proxy of C++ ProbabilityBoltzmannDownhill class."""

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

    def __init__(self, seed=0):
        r"""__init__(ProbabilityBoltzmannDownhill self, unsigned long seed=0) -> ProbabilityBoltzmannDownhill"""
        _QuantLib.ProbabilityBoltzmannDownhill_swiginit(self, _QuantLib.new_ProbabilityBoltzmannDownhill(seed))
    __swig_destroy__ = _QuantLib.delete_ProbabilityBoltzmannDownhill

# Register ProbabilityBoltzmannDownhill in _QuantLib:
_QuantLib.ProbabilityBoltzmannDownhill_swigregister(ProbabilityBoltzmannDownhill)
class TemperatureExponential(object):
    r"""Proxy of C++ TemperatureExponential class."""

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

    def __init__(self, initialTemp, dimension, power=0.95):
        r"""__init__(TemperatureExponential self, Real initialTemp, Size dimension, Real power=0.95) -> TemperatureExponential"""
        _QuantLib.TemperatureExponential_swiginit(self, _QuantLib.new_TemperatureExponential(initialTemp, dimension, power))
    __swig_destroy__ = _QuantLib.delete_TemperatureExponential

# Register TemperatureExponential in _QuantLib:
_QuantLib.TemperatureExponential_swigregister(TemperatureExponential)
class ReannealingTrivial(object):
    r"""Proxy of C++ ReannealingTrivial class."""

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

    def __init__(self):
        r"""__init__(ReannealingTrivial self) -> ReannealingTrivial"""
        _QuantLib.ReannealingTrivial_swiginit(self, _QuantLib.new_ReannealingTrivial())
    __swig_destroy__ = _QuantLib.delete_ReannealingTrivial

# Register ReannealingTrivial in _QuantLib:
_QuantLib.ReannealingTrivial_swigregister(ReannealingTrivial)
class GaussianSimulatedAnnealing(OptimizationMethod):
    r"""Proxy of C++ GaussianSimulatedAnnealing class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoResetScheme = _QuantLib.GaussianSimulatedAnnealing_NoResetScheme
    
    ResetToBestPoint = _QuantLib.GaussianSimulatedAnnealing_ResetToBestPoint
    
    ResetToOrigin = _QuantLib.GaussianSimulatedAnnealing_ResetToOrigin
    

    def __init__(self, *args):
        r"""__init__(GaussianSimulatedAnnealing self, SamplerGaussian sampler, ProbabilityBoltzmannDownhill probability, TemperatureExponential temperature, ReannealingTrivial reannealing=ReannealingTrivial(), Real startTemperature=200.0, Real endTemperature=0.01, Size reAnnealSteps=50, GaussianSimulatedAnnealing::ResetScheme resetScheme=ResetToBestPoint, Size resetSteps=150) -> GaussianSimulatedAnnealing"""
        _QuantLib.GaussianSimulatedAnnealing_swiginit(self, _QuantLib.new_GaussianSimulatedAnnealing(*args))
    __swig_destroy__ = _QuantLib.delete_GaussianSimulatedAnnealing

# Register GaussianSimulatedAnnealing in _QuantLib:
_QuantLib.GaussianSimulatedAnnealing_swigregister(GaussianSimulatedAnnealing)
class MirrorGaussianSimulatedAnnealing(OptimizationMethod):
    r"""Proxy of C++ MirrorGaussianSimulatedAnnealing class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoResetScheme = _QuantLib.MirrorGaussianSimulatedAnnealing_NoResetScheme
    
    ResetToBestPoint = _QuantLib.MirrorGaussianSimulatedAnnealing_ResetToBestPoint
    
    ResetToOrigin = _QuantLib.MirrorGaussianSimulatedAnnealing_ResetToOrigin
    

    def __init__(self, *args):
        r"""__init__(MirrorGaussianSimulatedAnnealing self, SamplerMirrorGaussian sampler, ProbabilityBoltzmannDownhill probability, TemperatureExponential temperature, ReannealingTrivial reannealing=ReannealingTrivial(), Real startTemperature=200.0, Real endTemperature=0.01, Size reAnnealSteps=50, MirrorGaussianSimulatedAnnealing::ResetScheme resetScheme=ResetToBestPoint, Size resetSteps=150) -> MirrorGaussianSimulatedAnnealing"""
        _QuantLib.MirrorGaussianSimulatedAnnealing_swiginit(self, _QuantLib.new_MirrorGaussianSimulatedAnnealing(*args))
    __swig_destroy__ = _QuantLib.delete_MirrorGaussianSimulatedAnnealing

# Register MirrorGaussianSimulatedAnnealing in _QuantLib:
_QuantLib.MirrorGaussianSimulatedAnnealing_swigregister(MirrorGaussianSimulatedAnnealing)
class LogNormalSimulatedAnnealing(OptimizationMethod):
    r"""Proxy of C++ LogNormalSimulatedAnnealing class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoResetScheme = _QuantLib.LogNormalSimulatedAnnealing_NoResetScheme
    
    ResetToBestPoint = _QuantLib.LogNormalSimulatedAnnealing_ResetToBestPoint
    
    ResetToOrigin = _QuantLib.LogNormalSimulatedAnnealing_ResetToOrigin
    

    def __init__(self, *args):
        r"""__init__(LogNormalSimulatedAnnealing self, SamplerLogNormal sampler, ProbabilityBoltzmannDownhill probability, TemperatureExponential temperature, ReannealingTrivial reannealing=ReannealingTrivial(), Real startTemperature=10.0, Real endTemperature=0.01, Size reAnnealSteps=50, LogNormalSimulatedAnnealing::ResetScheme resetScheme=ResetToBestPoint, Size resetSteps=150) -> LogNormalSimulatedAnnealing"""
        _QuantLib.LogNormalSimulatedAnnealing_swiginit(self, _QuantLib.new_LogNormalSimulatedAnnealing(*args))
    __swig_destroy__ = _QuantLib.delete_LogNormalSimulatedAnnealing

# Register LogNormalSimulatedAnnealing in _QuantLib:
_QuantLib.LogNormalSimulatedAnnealing_swigregister(LogNormalSimulatedAnnealing)
class Optimizer(object):
    r"""Proxy of C++ Optimizer class."""

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

    def solve(self, function, c, m, e, iv):
        r"""solve(Optimizer self, PyObject * function, Constraint c, OptimizationMethod m, EndCriteria e, Array iv) -> Array"""
        return _QuantLib.Optimizer_solve(self, function, c, m, e, iv)

    def __init__(self):
        r"""__init__(Optimizer self) -> Optimizer"""
        _QuantLib.Optimizer_swiginit(self, _QuantLib.new_Optimizer())
    __swig_destroy__ = _QuantLib.delete_Optimizer

# Register Optimizer in _QuantLib:
_QuantLib.Optimizer_swigregister(Optimizer)
class LinearInterpolation(object):
    r"""Proxy of C++ SafeLinearInterpolation class."""

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

    def __init__(self, x, y):
        r"""__init__(LinearInterpolation self, Array x, Array y) -> LinearInterpolation"""
        _QuantLib.LinearInterpolation_swiginit(self, _QuantLib.new_LinearInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(LinearInterpolation self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.LinearInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_LinearInterpolation

# Register LinearInterpolation in _QuantLib:
_QuantLib.LinearInterpolation_swigregister(LinearInterpolation)
class LogLinearInterpolation(object):
    r"""Proxy of C++ SafeLogLinearInterpolation class."""

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

    def __init__(self, x, y):
        r"""__init__(LogLinearInterpolation self, Array x, Array y) -> LogLinearInterpolation"""
        _QuantLib.LogLinearInterpolation_swiginit(self, _QuantLib.new_LogLinearInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(LogLinearInterpolation self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.LogLinearInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_LogLinearInterpolation

# Register LogLinearInterpolation in _QuantLib:
_QuantLib.LogLinearInterpolation_swigregister(LogLinearInterpolation)
class BackwardFlatInterpolation(object):
    r"""Proxy of C++ SafeBackwardFlatInterpolation class."""

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

    def __init__(self, x, y):
        r"""__init__(BackwardFlatInterpolation self, Array x, Array y) -> BackwardFlatInterpolation"""
        _QuantLib.BackwardFlatInterpolation_swiginit(self, _QuantLib.new_BackwardFlatInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(BackwardFlatInterpolation self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.BackwardFlatInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BackwardFlatInterpolation

# Register BackwardFlatInterpolation in _QuantLib:
_QuantLib.BackwardFlatInterpolation_swigregister(BackwardFlatInterpolation)
class ForwardFlatInterpolation(object):
    r"""Proxy of C++ SafeForwardFlatInterpolation class."""

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

    def __init__(self, x, y):
        r"""__init__(ForwardFlatInterpolation self, Array x, Array y) -> ForwardFlatInterpolation"""
        _QuantLib.ForwardFlatInterpolation_swiginit(self, _QuantLib.new_ForwardFlatInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(ForwardFlatInterpolation self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.ForwardFlatInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_ForwardFlatInterpolation

# Register ForwardFlatInterpolation in _QuantLib:
_QuantLib.ForwardFlatInterpolation_swigregister(ForwardFlatInterpolation)
class CubicNaturalSpline(object):
    r"""Proxy of C++ SafeCubicNaturalSpline class."""

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

    def __init__(self, x, y):
        r"""__init__(CubicNaturalSpline self, Array x, Array y) -> CubicNaturalSpline"""
        _QuantLib.CubicNaturalSpline_swiginit(self, _QuantLib.new_CubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(CubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.CubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(CubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.CubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(CubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.CubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(CubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.CubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_CubicNaturalSpline

# Register CubicNaturalSpline in _QuantLib:
_QuantLib.CubicNaturalSpline_swigregister(CubicNaturalSpline)
class LogCubicNaturalSpline(object):
    r"""Proxy of C++ SafeLogCubicNaturalSpline class."""

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

    def __init__(self, x, y):
        r"""__init__(LogCubicNaturalSpline self, Array x, Array y) -> LogCubicNaturalSpline"""
        _QuantLib.LogCubicNaturalSpline_swiginit(self, _QuantLib.new_LogCubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(LogCubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.LogCubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(LogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.LogCubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(LogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.LogCubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(LogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.LogCubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_LogCubicNaturalSpline

# Register LogCubicNaturalSpline in _QuantLib:
_QuantLib.LogCubicNaturalSpline_swigregister(LogCubicNaturalSpline)
class MonotonicCubicNaturalSpline(object):
    r"""Proxy of C++ SafeMonotonicCubicNaturalSpline class."""

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

    def __init__(self, x, y):
        r"""__init__(MonotonicCubicNaturalSpline self, Array x, Array y) -> MonotonicCubicNaturalSpline"""
        _QuantLib.MonotonicCubicNaturalSpline_swiginit(self, _QuantLib.new_MonotonicCubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(MonotonicCubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.MonotonicCubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(MonotonicCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicCubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(MonotonicCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicCubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(MonotonicCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicCubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicNaturalSpline

# Register MonotonicCubicNaturalSpline in _QuantLib:
_QuantLib.MonotonicCubicNaturalSpline_swigregister(MonotonicCubicNaturalSpline)
class MonotonicLogCubicNaturalSpline(object):
    r"""Proxy of C++ SafeMonotonicLogCubicNaturalSpline class."""

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

    def __init__(self, x, y):
        r"""__init__(MonotonicLogCubicNaturalSpline self, Array x, Array y) -> MonotonicLogCubicNaturalSpline"""
        _QuantLib.MonotonicLogCubicNaturalSpline_swiginit(self, _QuantLib.new_MonotonicLogCubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(MonotonicLogCubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.MonotonicLogCubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(MonotonicLogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicLogCubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(MonotonicLogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicLogCubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(MonotonicLogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicLogCubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubicNaturalSpline

# Register MonotonicLogCubicNaturalSpline in _QuantLib:
_QuantLib.MonotonicLogCubicNaturalSpline_swigregister(MonotonicLogCubicNaturalSpline)
class KrugerCubic(object):
    r"""Proxy of C++ SafeKrugerCubic class."""

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

    def __init__(self, x, y):
        r"""__init__(KrugerCubic self, Array x, Array y) -> KrugerCubic"""
        _QuantLib.KrugerCubic_swiginit(self, _QuantLib.new_KrugerCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(KrugerCubic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.KrugerCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(KrugerCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.KrugerCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(KrugerCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.KrugerCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(KrugerCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.KrugerCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_KrugerCubic

# Register KrugerCubic in _QuantLib:
_QuantLib.KrugerCubic_swigregister(KrugerCubic)
class KrugerLogCubic(object):
    r"""Proxy of C++ SafeKrugerLogCubic class."""

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

    def __init__(self, x, y):
        r"""__init__(KrugerLogCubic self, Array x, Array y) -> KrugerLogCubic"""
        _QuantLib.KrugerLogCubic_swiginit(self, _QuantLib.new_KrugerLogCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(KrugerLogCubic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.KrugerLogCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(KrugerLogCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.KrugerLogCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(KrugerLogCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.KrugerLogCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(KrugerLogCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.KrugerLogCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_KrugerLogCubic

# Register KrugerLogCubic in _QuantLib:
_QuantLib.KrugerLogCubic_swigregister(KrugerLogCubic)
class FritschButlandCubic(object):
    r"""Proxy of C++ SafeFritschButlandCubic class."""

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

    def __init__(self, x, y):
        r"""__init__(FritschButlandCubic self, Array x, Array y) -> FritschButlandCubic"""
        _QuantLib.FritschButlandCubic_swiginit(self, _QuantLib.new_FritschButlandCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(FritschButlandCubic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.FritschButlandCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(FritschButlandCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.FritschButlandCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(FritschButlandCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.FritschButlandCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(FritschButlandCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.FritschButlandCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_FritschButlandCubic

# Register FritschButlandCubic in _QuantLib:
_QuantLib.FritschButlandCubic_swigregister(FritschButlandCubic)
class FritschButlandLogCubic(object):
    r"""Proxy of C++ SafeFritschButlandLogCubic class."""

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

    def __init__(self, x, y):
        r"""__init__(FritschButlandLogCubic self, Array x, Array y) -> FritschButlandLogCubic"""
        _QuantLib.FritschButlandLogCubic_swiginit(self, _QuantLib.new_FritschButlandLogCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(FritschButlandLogCubic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.FritschButlandLogCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(FritschButlandLogCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.FritschButlandLogCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(FritschButlandLogCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.FritschButlandLogCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(FritschButlandLogCubic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.FritschButlandLogCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_FritschButlandLogCubic

# Register FritschButlandLogCubic in _QuantLib:
_QuantLib.FritschButlandLogCubic_swigregister(FritschButlandLogCubic)
class Parabolic(object):
    r"""Proxy of C++ SafeParabolic class."""

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

    def __init__(self, x, y):
        r"""__init__(Parabolic self, Array x, Array y) -> Parabolic"""
        _QuantLib.Parabolic_swiginit(self, _QuantLib.new_Parabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(Parabolic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.Parabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(Parabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.Parabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(Parabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.Parabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(Parabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.Parabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_Parabolic

# Register Parabolic in _QuantLib:
_QuantLib.Parabolic_swigregister(Parabolic)
class LogParabolic(object):
    r"""Proxy of C++ SafeLogParabolic class."""

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

    def __init__(self, x, y):
        r"""__init__(LogParabolic self, Array x, Array y) -> LogParabolic"""
        _QuantLib.LogParabolic_swiginit(self, _QuantLib.new_LogParabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(LogParabolic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.LogParabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(LogParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.LogParabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(LogParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.LogParabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(LogParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.LogParabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_LogParabolic

# Register LogParabolic in _QuantLib:
_QuantLib.LogParabolic_swigregister(LogParabolic)
class MonotonicParabolic(object):
    r"""Proxy of C++ SafeMonotonicParabolic class."""

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

    def __init__(self, x, y):
        r"""__init__(MonotonicParabolic self, Array x, Array y) -> MonotonicParabolic"""
        _QuantLib.MonotonicParabolic_swiginit(self, _QuantLib.new_MonotonicParabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(MonotonicParabolic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.MonotonicParabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(MonotonicParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicParabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(MonotonicParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicParabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(MonotonicParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicParabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicParabolic

# Register MonotonicParabolic in _QuantLib:
_QuantLib.MonotonicParabolic_swigregister(MonotonicParabolic)
class MonotonicLogParabolic(object):
    r"""Proxy of C++ SafeMonotonicLogParabolic class."""

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

    def __init__(self, x, y):
        r"""__init__(MonotonicLogParabolic self, Array x, Array y) -> MonotonicLogParabolic"""
        _QuantLib.MonotonicLogParabolic_swiginit(self, _QuantLib.new_MonotonicLogParabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(MonotonicLogParabolic self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.MonotonicLogParabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        r"""derivative(MonotonicLogParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicLogParabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        r"""secondDerivative(MonotonicLogParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicLogParabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        r"""primitive(MonotonicLogParabolic self, Real x, bool extrapolate=False) -> Real"""
        return _QuantLib.MonotonicLogParabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogParabolic

# Register MonotonicLogParabolic in _QuantLib:
_QuantLib.MonotonicLogParabolic_swigregister(MonotonicLogParabolic)
class BilinearInterpolation(object):
    r"""Proxy of C++ SafeBilinearInterpolation class."""

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

    def __init__(self, x, y, m):
        r"""__init__(BilinearInterpolation self, Array x, Array y, Matrix m) -> BilinearInterpolation"""
        _QuantLib.BilinearInterpolation_swiginit(self, _QuantLib.new_BilinearInterpolation(x, y, m))

    def __call__(self, x, y, allowExtrapolation=False):
        r"""__call__(BilinearInterpolation self, Real x, Real y, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.BilinearInterpolation___call__(self, x, y, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BilinearInterpolation

# Register BilinearInterpolation in _QuantLib:
_QuantLib.BilinearInterpolation_swigregister(BilinearInterpolation)
class BicubicSpline(object):
    r"""Proxy of C++ SafeBicubicSpline class."""

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

    def __init__(self, x, y, m):
        r"""__init__(BicubicSpline self, Array x, Array y, Matrix m) -> BicubicSpline"""
        _QuantLib.BicubicSpline_swiginit(self, _QuantLib.new_BicubicSpline(x, y, m))

    def __call__(self, x, y, allowExtrapolation=False):
        r"""__call__(BicubicSpline self, Real x, Real y, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.BicubicSpline___call__(self, x, y, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BicubicSpline

# Register BicubicSpline in _QuantLib:
_QuantLib.BicubicSpline_swigregister(BicubicSpline)
class BackwardFlat(object):
    r"""Proxy of C++ BackwardFlat class."""

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

    def __init__(self):
        r"""__init__(BackwardFlat self) -> BackwardFlat"""
        _QuantLib.BackwardFlat_swiginit(self, _QuantLib.new_BackwardFlat())
    __swig_destroy__ = _QuantLib.delete_BackwardFlat

# Register BackwardFlat in _QuantLib:
_QuantLib.BackwardFlat_swigregister(BackwardFlat)
class ForwardFlat(object):
    r"""Proxy of C++ ForwardFlat class."""

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

    def __init__(self):
        r"""__init__(ForwardFlat self) -> ForwardFlat"""
        _QuantLib.ForwardFlat_swiginit(self, _QuantLib.new_ForwardFlat())
    __swig_destroy__ = _QuantLib.delete_ForwardFlat

# Register ForwardFlat in _QuantLib:
_QuantLib.ForwardFlat_swigregister(ForwardFlat)
class Linear(object):
    r"""Proxy of C++ Linear class."""

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

    def __init__(self):
        r"""__init__(Linear self) -> Linear"""
        _QuantLib.Linear_swiginit(self, _QuantLib.new_Linear())
    __swig_destroy__ = _QuantLib.delete_Linear

# Register Linear in _QuantLib:
_QuantLib.Linear_swigregister(Linear)
class LogLinear(object):
    r"""Proxy of C++ LogLinear class."""

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

    def __init__(self):
        r"""__init__(LogLinear self) -> LogLinear"""
        _QuantLib.LogLinear_swiginit(self, _QuantLib.new_LogLinear())
    __swig_destroy__ = _QuantLib.delete_LogLinear

# Register LogLinear in _QuantLib:
_QuantLib.LogLinear_swigregister(LogLinear)
class Cubic(object):
    r"""Proxy of C++ Cubic class."""

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

    def __init__(self):
        r"""__init__(Cubic self) -> Cubic"""
        _QuantLib.Cubic_swiginit(self, _QuantLib.new_Cubic())
    __swig_destroy__ = _QuantLib.delete_Cubic

# Register Cubic in _QuantLib:
_QuantLib.Cubic_swigregister(Cubic)
class Bicubic(object):
    r"""Proxy of C++ Bicubic class."""

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

    def __init__(self):
        r"""__init__(Bicubic self) -> Bicubic"""
        _QuantLib.Bicubic_swiginit(self, _QuantLib.new_Bicubic())
    __swig_destroy__ = _QuantLib.delete_Bicubic

# Register Bicubic in _QuantLib:
_QuantLib.Bicubic_swigregister(Bicubic)
class MonotonicCubic(object):
    r"""Proxy of C++ MonotonicCubic class."""

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

    def __init__(self):
        r"""__init__(MonotonicCubic self) -> MonotonicCubic"""
        _QuantLib.MonotonicCubic_swiginit(self, _QuantLib.new_MonotonicCubic())
    __swig_destroy__ = _QuantLib.delete_MonotonicCubic

# Register MonotonicCubic in _QuantLib:
_QuantLib.MonotonicCubic_swigregister(MonotonicCubic)
class DefaultLogCubic(object):
    r"""Proxy of C++ DefaultLogCubic class."""

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

    def __init__(self):
        r"""__init__(DefaultLogCubic self) -> DefaultLogCubic"""
        _QuantLib.DefaultLogCubic_swiginit(self, _QuantLib.new_DefaultLogCubic())
    __swig_destroy__ = _QuantLib.delete_DefaultLogCubic

# Register DefaultLogCubic in _QuantLib:
_QuantLib.DefaultLogCubic_swigregister(DefaultLogCubic)
class MonotonicLogCubic(object):
    r"""Proxy of C++ MonotonicLogCubic class."""

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

    def __init__(self):
        r"""__init__(MonotonicLogCubic self) -> MonotonicLogCubic"""
        _QuantLib.MonotonicLogCubic_swiginit(self, _QuantLib.new_MonotonicLogCubic())
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubic

# Register MonotonicLogCubic in _QuantLib:
_QuantLib.MonotonicLogCubic_swigregister(MonotonicLogCubic)
class SplineCubic(object):
    r"""Proxy of C++ SplineCubic class."""

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

    def __init__(self):
        r"""__init__(SplineCubic self) -> SplineCubic"""
        _QuantLib.SplineCubic_swiginit(self, _QuantLib.new_SplineCubic())
    __swig_destroy__ = _QuantLib.delete_SplineCubic

# Register SplineCubic in _QuantLib:
_QuantLib.SplineCubic_swigregister(SplineCubic)
class SplineLogCubic(object):
    r"""Proxy of C++ SplineLogCubic class."""

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

    def __init__(self):
        r"""__init__(SplineLogCubic self) -> SplineLogCubic"""
        _QuantLib.SplineLogCubic_swiginit(self, _QuantLib.new_SplineLogCubic())
    __swig_destroy__ = _QuantLib.delete_SplineLogCubic

# Register SplineLogCubic in _QuantLib:
_QuantLib.SplineLogCubic_swigregister(SplineLogCubic)
class Kruger(object):
    r"""Proxy of C++ Kruger class."""

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

    def __init__(self):
        r"""__init__(Kruger self) -> Kruger"""
        _QuantLib.Kruger_swiginit(self, _QuantLib.new_Kruger())
    __swig_destroy__ = _QuantLib.delete_Kruger

# Register Kruger in _QuantLib:
_QuantLib.Kruger_swigregister(Kruger)
class KrugerLog(object):
    r"""Proxy of C++ KrugerLog class."""

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

    def __init__(self):
        r"""__init__(KrugerLog self) -> KrugerLog"""
        _QuantLib.KrugerLog_swiginit(self, _QuantLib.new_KrugerLog())
    __swig_destroy__ = _QuantLib.delete_KrugerLog

# Register KrugerLog in _QuantLib:
_QuantLib.KrugerLog_swigregister(KrugerLog)
class ConvexMonotone(object):
    r"""Proxy of C++ ConvexMonotone class."""

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

    def __init__(self, quadraticity=0.3, monotonicity=0.7, forcePositive=True):
        r"""__init__(ConvexMonotone self, Real quadraticity=0.3, Real monotonicity=0.7, bool forcePositive=True) -> ConvexMonotone"""
        _QuantLib.ConvexMonotone_swiginit(self, _QuantLib.new_ConvexMonotone(quadraticity, monotonicity, forcePositive))
    __swig_destroy__ = _QuantLib.delete_ConvexMonotone

# Register ConvexMonotone in _QuantLib:
_QuantLib.ConvexMonotone_swigregister(ConvexMonotone)
class SABRInterpolation(object):
    r"""Proxy of C++ SafeSABRInterpolation class."""

    thisown = 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):
        r"""__init__(SABRInterpolation self, Array x, Array y, Time t, Real forward, Real alpha, Real beta, Real nu, Real rho, bool alphaIsFixed=False, bool betaIsFixed=False, bool nuIsFixed=False, bool rhoIsFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & optMethod=ext::shared_ptr< OptimizationMethod >(), Real const errorAccept=0.0020, bool const useMaxError=False, Size const maxGuesses=50, Real const shift=0.0) -> SABRInterpolation"""
        _QuantLib.SABRInterpolation_swiginit(self, _QuantLib.new_SABRInterpolation(*args, **kwargs))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(SABRInterpolation self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.SABRInterpolation___call__(self, x, allowExtrapolation)

    def alpha(self):
        r"""alpha(SABRInterpolation self) -> Real"""
        return _QuantLib.SABRInterpolation_alpha(self)

    def beta(self):
        r"""beta(SABRInterpolation self) -> Real"""
        return _QuantLib.SABRInterpolation_beta(self)

    def rho(self):
        r"""rho(SABRInterpolation self) -> Real"""
        return _QuantLib.SABRInterpolation_rho(self)

    def nu(self):
        r"""nu(SABRInterpolation self) -> Real"""
        return _QuantLib.SABRInterpolation_nu(self)
    __swig_destroy__ = _QuantLib.delete_SABRInterpolation

# Register SABRInterpolation in _QuantLib:
_QuantLib.SABRInterpolation_swigregister(SABRInterpolation)
class RichardsonExtrapolation(object):
    r"""Proxy of C++ RichardsonExtrapolation class."""

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

    def __call__(self, *args):
        r"""
        __call__(RichardsonExtrapolation self, Real t=2.0) -> Real
        __call__(RichardsonExtrapolation self, Real t, Real s) -> Real
        """
        return _QuantLib.RichardsonExtrapolation___call__(self, *args)

    def __init__(self, *args):
        r"""__init__(RichardsonExtrapolation self, PyObject * fct, Real delta_h, Real n=Null< Real >()) -> RichardsonExtrapolation"""
        _QuantLib.RichardsonExtrapolation_swiginit(self, _QuantLib.new_RichardsonExtrapolation(*args))
    __swig_destroy__ = _QuantLib.delete_RichardsonExtrapolation

# Register RichardsonExtrapolation in _QuantLib:
_QuantLib.RichardsonExtrapolation_swigregister(RichardsonExtrapolation)
class ChebyshevInterpolation(object):
    r"""Proxy of C++ ChebyshevInterpolation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FirstKind = _QuantLib.ChebyshevInterpolation_FirstKind
    
    SecondKind = _QuantLib.ChebyshevInterpolation_SecondKind
    

    def __init__(self, *args):
        r"""
        __init__(ChebyshevInterpolation self, Array f, ChebyshevInterpolation::PointsType pointsType=SecondKind) -> ChebyshevInterpolation
        __init__(ChebyshevInterpolation self, Size n, PyObject * fct, ChebyshevInterpolation::PointsType pointsType=SecondKind) -> ChebyshevInterpolation
        """
        _QuantLib.ChebyshevInterpolation_swiginit(self, _QuantLib.new_ChebyshevInterpolation(*args))

    def __call__(self, z, allowExtrapolation=False):
        r"""__call__(ChebyshevInterpolation self, Real z, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.ChebyshevInterpolation___call__(self, z, allowExtrapolation)

    @staticmethod
    def nodes(n, pointsType):
        r"""nodes(Size n, ChebyshevInterpolation::PointsType pointsType) -> Array"""
        return _QuantLib.ChebyshevInterpolation_nodes(n, pointsType)
    __swig_destroy__ = _QuantLib.delete_ChebyshevInterpolation

# Register ChebyshevInterpolation in _QuantLib:
_QuantLib.ChebyshevInterpolation_swigregister(ChebyshevInterpolation)
class ConvexMonotoneInterpolation(object):
    r"""Proxy of C++ SafeConvexMonotoneInterpolation class."""

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

    def __init__(self, x, y, quadraticity=0.3, monotonicity=0.7, forcePositive=True):
        r"""__init__(ConvexMonotoneInterpolation self, Array x, Array y, Real quadraticity=0.3, Real monotonicity=0.7, bool forcePositive=True) -> ConvexMonotoneInterpolation"""
        _QuantLib.ConvexMonotoneInterpolation_swiginit(self, _QuantLib.new_ConvexMonotoneInterpolation(x, y, quadraticity, monotonicity, forcePositive))

    def __call__(self, x, allowExtrapolation=False):
        r"""__call__(ConvexMonotoneInterpolation self, Real x, bool allowExtrapolation=False) -> Real"""
        return _QuantLib.ConvexMonotoneInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_ConvexMonotoneInterpolation

# Register ConvexMonotoneInterpolation in _QuantLib:
_QuantLib.ConvexMonotoneInterpolation_swigregister(ConvexMonotoneInterpolation)
class TermStructure(Observable):
    r"""Proxy of C++ TermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def dayCounter(self):
        r"""dayCounter(TermStructure self) -> DayCounter"""
        return _QuantLib.TermStructure_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(TermStructure self, Date date) -> Time"""
        return _QuantLib.TermStructure_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(TermStructure self) -> Calendar"""
        return _QuantLib.TermStructure_calendar(self)

    def referenceDate(self):
        r"""referenceDate(TermStructure self) -> Date"""
        return _QuantLib.TermStructure_referenceDate(self)

    def maxDate(self):
        r"""maxDate(TermStructure self) -> Date"""
        return _QuantLib.TermStructure_maxDate(self)

    def maxTime(self):
        r"""maxTime(TermStructure self) -> Time"""
        return _QuantLib.TermStructure_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(TermStructure self)"""
        return _QuantLib.TermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(TermStructure self)"""
        return _QuantLib.TermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(TermStructure self) -> bool"""
        return _QuantLib.TermStructure_allowsExtrapolation(self)
    __swig_destroy__ = _QuantLib.delete_TermStructure

# Register TermStructure in _QuantLib:
_QuantLib.TermStructure_swigregister(TermStructure)
class YieldTermStructure(TermStructure):
    r"""Proxy of C++ YieldTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def discount(self, *args):
        r"""
        discount(YieldTermStructure self, Date arg2, bool extrapolate=False) -> DiscountFactor
        discount(YieldTermStructure self, Time arg2, bool extrapolate=False) -> DiscountFactor
        """
        return _QuantLib.YieldTermStructure_discount(self, *args)

    def zeroRate(self, *args):
        r"""
        zeroRate(YieldTermStructure self, Date d, DayCounter arg3, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        zeroRate(YieldTermStructure self, Time t, Compounding arg3, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        """
        return _QuantLib.YieldTermStructure_zeroRate(self, *args)

    def forwardRate(self, *args):
        r"""
        forwardRate(YieldTermStructure self, Date d1, Date d2, DayCounter arg4, Compounding arg5, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        forwardRate(YieldTermStructure self, Time t1, Time t2, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        """
        return _QuantLib.YieldTermStructure_forwardRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_YieldTermStructure

# Register YieldTermStructure in _QuantLib:
_QuantLib.YieldTermStructure_swigregister(YieldTermStructure)
class YieldTermStructureHandle(object):
    r"""Proxy of C++ Handle< YieldTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(YieldTermStructureHandle self, ext::shared_ptr< YieldTermStructure > const & arg2=ext::shared_ptr()) -> YieldTermStructureHandle"""
        _QuantLib.YieldTermStructureHandle_swiginit(self, _QuantLib.new_YieldTermStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(YieldTermStructureHandle self) -> ext::shared_ptr< YieldTermStructure >"""
        return _QuantLib.YieldTermStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(YieldTermStructureHandle self) -> ext::shared_ptr< YieldTermStructure >"""
        return _QuantLib.YieldTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(YieldTermStructureHandle self) -> bool"""
        return _QuantLib.YieldTermStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(YieldTermStructureHandle self) -> bool"""
        return _QuantLib.YieldTermStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(YieldTermStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.YieldTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YieldTermStructureHandle

    def discount(self, *args):
        r"""
        discount(YieldTermStructureHandle self, Date arg2, bool extrapolate=False) -> DiscountFactor
        discount(YieldTermStructureHandle self, Time arg2, bool extrapolate=False) -> DiscountFactor
        """
        return _QuantLib.YieldTermStructureHandle_discount(self, *args)

    def zeroRate(self, *args):
        r"""
        zeroRate(YieldTermStructureHandle self, Date d, DayCounter arg3, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        zeroRate(YieldTermStructureHandle self, Time t, Compounding arg3, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        """
        return _QuantLib.YieldTermStructureHandle_zeroRate(self, *args)

    def forwardRate(self, *args):
        r"""
        forwardRate(YieldTermStructureHandle self, Date d1, Date d2, DayCounter arg4, Compounding arg5, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        forwardRate(YieldTermStructureHandle self, Time t1, Time t2, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate
        """
        return _QuantLib.YieldTermStructureHandle_forwardRate(self, *args)

    def dayCounter(self):
        r"""dayCounter(YieldTermStructureHandle self) -> DayCounter"""
        return _QuantLib.YieldTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(YieldTermStructureHandle self, Date date) -> Time"""
        return _QuantLib.YieldTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(YieldTermStructureHandle self) -> Calendar"""
        return _QuantLib.YieldTermStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(YieldTermStructureHandle self) -> Date"""
        return _QuantLib.YieldTermStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(YieldTermStructureHandle self) -> Date"""
        return _QuantLib.YieldTermStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(YieldTermStructureHandle self) -> Time"""
        return _QuantLib.YieldTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(YieldTermStructureHandle self)"""
        return _QuantLib.YieldTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(YieldTermStructureHandle self)"""
        return _QuantLib.YieldTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(YieldTermStructureHandle self) -> bool"""
        return _QuantLib.YieldTermStructureHandle_allowsExtrapolation(self)

# Register YieldTermStructureHandle in _QuantLib:
_QuantLib.YieldTermStructureHandle_swigregister(YieldTermStructureHandle)
class RelinkableYieldTermStructureHandle(YieldTermStructureHandle):
    r"""Proxy of C++ RelinkableHandle< YieldTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableYieldTermStructureHandle self, ext::shared_ptr< YieldTermStructure > const & arg2=ext::shared_ptr()) -> RelinkableYieldTermStructureHandle"""
        _QuantLib.RelinkableYieldTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableYieldTermStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableYieldTermStructureHandle self, ext::shared_ptr< YieldTermStructure > const & arg2)"""
        return _QuantLib.RelinkableYieldTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableYieldTermStructureHandle self)"""
        return _QuantLib.RelinkableYieldTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableYieldTermStructureHandle

# Register RelinkableYieldTermStructureHandle in _QuantLib:
_QuantLib.RelinkableYieldTermStructureHandle_swigregister(RelinkableYieldTermStructureHandle)
class ImpliedTermStructure(YieldTermStructure):
    r"""Proxy of C++ ImpliedTermStructure class."""

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

    def __init__(self, curveHandle, referenceDate):
        r"""__init__(ImpliedTermStructure self, YieldTermStructureHandle curveHandle, Date referenceDate) -> ImpliedTermStructure"""
        _QuantLib.ImpliedTermStructure_swiginit(self, _QuantLib.new_ImpliedTermStructure(curveHandle, referenceDate))
    __swig_destroy__ = _QuantLib.delete_ImpliedTermStructure

# Register ImpliedTermStructure in _QuantLib:
_QuantLib.ImpliedTermStructure_swigregister(ImpliedTermStructure)
class ZeroSpreadedTermStructure(YieldTermStructure):
    r"""Proxy of C++ ZeroSpreadedTermStructure class."""

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

    def __init__(self, *args):
        r"""__init__(ZeroSpreadedTermStructure self, YieldTermStructureHandle curveHandle, QuoteHandle spreadHandle, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter()) -> ZeroSpreadedTermStructure"""
        _QuantLib.ZeroSpreadedTermStructure_swiginit(self, _QuantLib.new_ZeroSpreadedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_ZeroSpreadedTermStructure

# Register ZeroSpreadedTermStructure in _QuantLib:
_QuantLib.ZeroSpreadedTermStructure_swigregister(ZeroSpreadedTermStructure)
class ForwardSpreadedTermStructure(YieldTermStructure):
    r"""Proxy of C++ ForwardSpreadedTermStructure class."""

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

    def __init__(self, curveHandle, spreadHandle):
        r"""__init__(ForwardSpreadedTermStructure self, YieldTermStructureHandle curveHandle, QuoteHandle spreadHandle) -> ForwardSpreadedTermStructure"""
        _QuantLib.ForwardSpreadedTermStructure_swiginit(self, _QuantLib.new_ForwardSpreadedTermStructure(curveHandle, spreadHandle))
    __swig_destroy__ = _QuantLib.delete_ForwardSpreadedTermStructure

# Register ForwardSpreadedTermStructure in _QuantLib:
_QuantLib.ForwardSpreadedTermStructure_swigregister(ForwardSpreadedTermStructure)
class PiecewiseZeroSpreadedTermStructure(YieldTermStructure):
    r"""Proxy of C++ InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > class."""

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

    def __init__(self, *args):
        r"""__init__(PiecewiseZeroSpreadedTermStructure self, YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter(), Linear factory=Linear()) -> PiecewiseZeroSpreadedTermStructure"""
        _QuantLib.PiecewiseZeroSpreadedTermStructure_swiginit(self, _QuantLib.new_PiecewiseZeroSpreadedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_PiecewiseZeroSpreadedTermStructure

# Register PiecewiseZeroSpreadedTermStructure in _QuantLib:
_QuantLib.PiecewiseZeroSpreadedTermStructure_swigregister(PiecewiseZeroSpreadedTermStructure)
class SpreadedLinearZeroInterpolatedTermStructure(YieldTermStructure):
    r"""Proxy of C++ InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > class."""

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

    def __init__(self, *args):
        r"""__init__(SpreadedLinearZeroInterpolatedTermStructure self, YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter(), Linear factory=Linear()) -> SpreadedLinearZeroInterpolatedTermStructure"""
        _QuantLib.SpreadedLinearZeroInterpolatedTermStructure_swiginit(self, _QuantLib.new_SpreadedLinearZeroInterpolatedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadedLinearZeroInterpolatedTermStructure

# Register SpreadedLinearZeroInterpolatedTermStructure in _QuantLib:
_QuantLib.SpreadedLinearZeroInterpolatedTermStructure_swigregister(SpreadedLinearZeroInterpolatedTermStructure)
class SpreadedBackwardFlatZeroInterpolatedTermStructure(YieldTermStructure):
    r"""Proxy of C++ InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > class."""

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

    def __init__(self, *args):
        r"""__init__(SpreadedBackwardFlatZeroInterpolatedTermStructure self, YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter(), BackwardFlat factory=BackwardFlat()) -> SpreadedBackwardFlatZeroInterpolatedTermStructure"""
        _QuantLib.SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit(self, _QuantLib.new_SpreadedBackwardFlatZeroInterpolatedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadedBackwardFlatZeroInterpolatedTermStructure

# Register SpreadedBackwardFlatZeroInterpolatedTermStructure in _QuantLib:
_QuantLib.SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister(SpreadedBackwardFlatZeroInterpolatedTermStructure)
class FlatForward(YieldTermStructure):
    r"""Proxy of C++ FlatForward class."""

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

    def __init__(self, *args):
        r"""
        __init__(FlatForward self, Date referenceDate, QuoteHandle forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual) -> FlatForward
        __init__(FlatForward self, Date referenceDate, Rate forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual) -> FlatForward
        __init__(FlatForward self, Integer settlementDays, Calendar calendar, QuoteHandle forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual) -> FlatForward
        __init__(FlatForward self, Integer settlementDays, Calendar calendar, Rate forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual) -> FlatForward
        """
        _QuantLib.FlatForward_swiginit(self, _QuantLib.new_FlatForward(*args))
    __swig_destroy__ = _QuantLib.delete_FlatForward

# Register FlatForward in _QuantLib:
_QuantLib.FlatForward_swigregister(FlatForward)
class UltimateForwardTermStructure(YieldTermStructure):
    r"""Proxy of C++ UltimateForwardTermStructure class."""

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

    def __init__(self, curveHandle, lastLiquidForwardRate, ultimateForwardRate, firstSmoothingPoint, alpha):
        r"""__init__(UltimateForwardTermStructure self, YieldTermStructureHandle curveHandle, QuoteHandle lastLiquidForwardRate, QuoteHandle ultimateForwardRate, Period firstSmoothingPoint, Real alpha) -> UltimateForwardTermStructure"""
        _QuantLib.UltimateForwardTermStructure_swiginit(self, _QuantLib.new_UltimateForwardTermStructure(curveHandle, lastLiquidForwardRate, ultimateForwardRate, firstSmoothingPoint, alpha))
    __swig_destroy__ = _QuantLib.delete_UltimateForwardTermStructure

# Register UltimateForwardTermStructure in _QuantLib:
_QuantLib.UltimateForwardTermStructure_swigregister(UltimateForwardTermStructure)
class CompositeZeroYieldStructure(YieldTermStructure):
    r"""
    Proxy of C++ CompositeZeroYieldStructure< BinaryFunction > class.
    Proxy of C++ CompositeZeroYieldStructure< BinaryFunction > class.
    """

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

    def __init__(self, *args):
        r"""__init__(CompositeZeroYieldStructure self, YieldTermStructureHandle h1, YieldTermStructureHandle h2, PyObject * function, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency) -> CompositeZeroYieldStructure"""
        _QuantLib.CompositeZeroYieldStructure_swiginit(self, _QuantLib.new_CompositeZeroYieldStructure(*args))
    __swig_destroy__ = _QuantLib.delete_CompositeZeroYieldStructure

# Register CompositeZeroYieldStructure in _QuantLib:
_QuantLib.CompositeZeroYieldStructure_swigregister(CompositeZeroYieldStructure)
class QuantoTermStructure(YieldTermStructure):
    r"""Proxy of C++ QuantoTermStructure class."""

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

    def __init__(self, underlyingDividendTS, riskFreeTS, foreignRiskFreeTS, underlyingBlackVolTS, strike, exchRateBlackVolTS, exchRateATMlevel, underlyingExchRateCorrelation):
        r"""__init__(QuantoTermStructure self, YieldTermStructureHandle underlyingDividendTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle foreignRiskFreeTS, BlackVolTermStructureHandle underlyingBlackVolTS, Real strike, BlackVolTermStructureHandle exchRateBlackVolTS, Real exchRateATMlevel, Real underlyingExchRateCorrelation) -> QuantoTermStructure"""
        _QuantLib.QuantoTermStructure_swiginit(self, _QuantLib.new_QuantoTermStructure(underlyingDividendTS, riskFreeTS, foreignRiskFreeTS, underlyingBlackVolTS, strike, exchRateBlackVolTS, exchRateATMlevel, underlyingExchRateCorrelation))
    __swig_destroy__ = _QuantLib.delete_QuantoTermStructure

# Register QuantoTermStructure in _QuantLib:
_QuantLib.QuantoTermStructure_swigregister(QuantoTermStructure)
class RealTimeSeries(object):
    r"""Proxy of C++ TimeSeries< Real > class."""

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

    def __init__(self, *args):
        r"""
        __init__(RealTimeSeries self) -> RealTimeSeries
        __init__(RealTimeSeries self, DateVector d, DoubleVector v) -> RealTimeSeries
        """
        _QuantLib.RealTimeSeries_swiginit(self, _QuantLib.new_RealTimeSeries(*args))

    def dates(self):
        r"""dates(RealTimeSeries self) -> DateVector"""
        return _QuantLib.RealTimeSeries_dates(self)

    def values(self):
        r"""values(RealTimeSeries self) -> DoubleVector"""
        return _QuantLib.RealTimeSeries_values(self)

    def __len__(self):
        r"""__len__(RealTimeSeries self) -> Size"""
        return _QuantLib.RealTimeSeries___len__(self)

    def __getitem__(self, d):
        r"""__getitem__(RealTimeSeries self, Date d) -> double"""
        return _QuantLib.RealTimeSeries___getitem__(self, d)

    def __setitem__(self, d, value):
        r"""__setitem__(RealTimeSeries self, Date d, double const & value)"""
        return _QuantLib.RealTimeSeries___setitem__(self, d, value)
    __swig_destroy__ = _QuantLib.delete_RealTimeSeries

# Register RealTimeSeries in _QuantLib:
_QuantLib.RealTimeSeries_swigregister(RealTimeSeries)
class IntervalPriceTimeSeries(object):
    r"""Proxy of C++ TimeSeries< IntervalPrice > class."""

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

    def __init__(self, *args):
        r"""
        __init__(IntervalPriceTimeSeries self) -> IntervalPriceTimeSeries
        __init__(IntervalPriceTimeSeries self, DateVector d, IntervalPriceVector v) -> IntervalPriceTimeSeries
        """
        _QuantLib.IntervalPriceTimeSeries_swiginit(self, _QuantLib.new_IntervalPriceTimeSeries(*args))

    def dates(self):
        r"""dates(IntervalPriceTimeSeries self) -> DateVector"""
        return _QuantLib.IntervalPriceTimeSeries_dates(self)

    def values(self):
        r"""values(IntervalPriceTimeSeries self) -> IntervalPriceVector"""
        return _QuantLib.IntervalPriceTimeSeries_values(self)

    def __len__(self):
        r"""__len__(IntervalPriceTimeSeries self) -> Size"""
        return _QuantLib.IntervalPriceTimeSeries___len__(self)

    def __getitem__(self, d):
        r"""__getitem__(IntervalPriceTimeSeries self, Date d) -> IntervalPrice"""
        return _QuantLib.IntervalPriceTimeSeries___getitem__(self, d)

    def __setitem__(self, d, value):
        r"""__setitem__(IntervalPriceTimeSeries self, Date d, IntervalPrice value)"""
        return _QuantLib.IntervalPriceTimeSeries___setitem__(self, d, value)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceTimeSeries

# Register IntervalPriceTimeSeries in _QuantLib:
_QuantLib.IntervalPriceTimeSeries_swigregister(IntervalPriceTimeSeries)
class IntervalPriceVector(object):
    r"""Proxy of C++ std::vector< IntervalPrice > class."""

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

    def iterator(self):
        r"""iterator(IntervalPriceVector self) -> SwigPyIterator"""
        return _QuantLib.IntervalPriceVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IntervalPriceVector self) -> bool"""
        return _QuantLib.IntervalPriceVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IntervalPriceVector self) -> bool"""
        return _QuantLib.IntervalPriceVector___bool__(self)

    def __len__(self):
        r"""__len__(IntervalPriceVector self) -> std::vector< IntervalPrice >::size_type"""
        return _QuantLib.IntervalPriceVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j) -> IntervalPriceVector"""
        return _QuantLib.IntervalPriceVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j)
        __setslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j, IntervalPriceVector v)
        """
        return _QuantLib.IntervalPriceVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j)"""
        return _QuantLib.IntervalPriceVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i)
        __delitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.IntervalPriceVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice) -> IntervalPriceVector
        __getitem__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i) -> IntervalPrice
        """
        return _QuantLib.IntervalPriceVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice, IntervalPriceVector v)
        __setitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, IntervalPrice x)
        """
        return _QuantLib.IntervalPriceVector___setitem__(self, *args)

    def pop(self):
        r"""pop(IntervalPriceVector self) -> IntervalPrice"""
        return _QuantLib.IntervalPriceVector_pop(self)

    def append(self, x):
        r"""append(IntervalPriceVector self, IntervalPrice x)"""
        return _QuantLib.IntervalPriceVector_append(self, x)

    def empty(self):
        r"""empty(IntervalPriceVector self) -> bool"""
        return _QuantLib.IntervalPriceVector_empty(self)

    def size(self):
        r"""size(IntervalPriceVector self) -> std::vector< IntervalPrice >::size_type"""
        return _QuantLib.IntervalPriceVector_size(self)

    def swap(self, v):
        r"""swap(IntervalPriceVector self, IntervalPriceVector v)"""
        return _QuantLib.IntervalPriceVector_swap(self, v)

    def begin(self):
        r"""begin(IntervalPriceVector self) -> std::vector< IntervalPrice >::iterator"""
        return _QuantLib.IntervalPriceVector_begin(self)

    def end(self):
        r"""end(IntervalPriceVector self) -> std::vector< IntervalPrice >::iterator"""
        return _QuantLib.IntervalPriceVector_end(self)

    def rbegin(self):
        r"""rbegin(IntervalPriceVector self) -> std::vector< IntervalPrice >::reverse_iterator"""
        return _QuantLib.IntervalPriceVector_rbegin(self)

    def rend(self):
        r"""rend(IntervalPriceVector self) -> std::vector< IntervalPrice >::reverse_iterator"""
        return _QuantLib.IntervalPriceVector_rend(self)

    def clear(self):
        r"""clear(IntervalPriceVector self)"""
        return _QuantLib.IntervalPriceVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(IntervalPriceVector self) -> std::vector< IntervalPrice >::allocator_type"""
        return _QuantLib.IntervalPriceVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IntervalPriceVector self)"""
        return _QuantLib.IntervalPriceVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IntervalPriceVector self, std::vector< IntervalPrice >::iterator pos) -> std::vector< IntervalPrice >::iterator
        erase(IntervalPriceVector self, std::vector< IntervalPrice >::iterator first, std::vector< IntervalPrice >::iterator last) -> std::vector< IntervalPrice >::iterator
        """
        return _QuantLib.IntervalPriceVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IntervalPriceVector self) -> IntervalPriceVector
        __init__(IntervalPriceVector self, IntervalPriceVector other) -> IntervalPriceVector
        __init__(IntervalPriceVector self, std::vector< IntervalPrice >::size_type size) -> IntervalPriceVector
        __init__(IntervalPriceVector self, std::vector< IntervalPrice >::size_type size, IntervalPrice value) -> IntervalPriceVector
        """
        _QuantLib.IntervalPriceVector_swiginit(self, _QuantLib.new_IntervalPriceVector(*args))

    def push_back(self, x):
        r"""push_back(IntervalPriceVector self, IntervalPrice x)"""
        return _QuantLib.IntervalPriceVector_push_back(self, x)

    def front(self):
        r"""front(IntervalPriceVector self) -> IntervalPrice"""
        return _QuantLib.IntervalPriceVector_front(self)

    def back(self):
        r"""back(IntervalPriceVector self) -> IntervalPrice"""
        return _QuantLib.IntervalPriceVector_back(self)

    def assign(self, n, x):
        r"""assign(IntervalPriceVector self, std::vector< IntervalPrice >::size_type n, IntervalPrice x)"""
        return _QuantLib.IntervalPriceVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IntervalPriceVector self, std::vector< IntervalPrice >::size_type new_size)
        resize(IntervalPriceVector self, std::vector< IntervalPrice >::size_type new_size, IntervalPrice x)
        """
        return _QuantLib.IntervalPriceVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IntervalPriceVector self, std::vector< IntervalPrice >::iterator pos, IntervalPrice x) -> std::vector< IntervalPrice >::iterator
        insert(IntervalPriceVector self, std::vector< IntervalPrice >::iterator pos, std::vector< IntervalPrice >::size_type n, IntervalPrice x)
        """
        return _QuantLib.IntervalPriceVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(IntervalPriceVector self, std::vector< IntervalPrice >::size_type n)"""
        return _QuantLib.IntervalPriceVector_reserve(self, n)

    def capacity(self):
        r"""capacity(IntervalPriceVector self) -> std::vector< IntervalPrice >::size_type"""
        return _QuantLib.IntervalPriceVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceVector

# Register IntervalPriceVector in _QuantLib:
_QuantLib.IntervalPriceVector_swigregister(IntervalPriceVector)
class IntervalPrice(object):
    r"""Proxy of C++ IntervalPrice class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Open = _QuantLib.IntervalPrice_Open
    
    Close = _QuantLib.IntervalPrice_Close
    
    High = _QuantLib.IntervalPrice_High
    
    Low = _QuantLib.IntervalPrice_Low
    

    def __init__(self, arg2, arg3, arg4, arg5):
        r"""__init__(IntervalPrice self, Real arg2, Real arg3, Real arg4, Real arg5) -> IntervalPrice"""
        _QuantLib.IntervalPrice_swiginit(self, _QuantLib.new_IntervalPrice(arg2, arg3, arg4, arg5))

    def setValue(self, arg2, arg3):
        r"""setValue(IntervalPrice self, Real arg2, IntervalPrice::Type arg3)"""
        return _QuantLib.IntervalPrice_setValue(self, arg2, arg3)

    def setValues(self, arg2, arg3, arg4, arg5):
        r"""setValues(IntervalPrice self, Real arg2, Real arg3, Real arg4, Real arg5)"""
        return _QuantLib.IntervalPrice_setValues(self, arg2, arg3, arg4, arg5)

    def value(self, t):
        r"""value(IntervalPrice self, IntervalPrice::Type t) -> Real"""
        return _QuantLib.IntervalPrice_value(self, t)

    def open(self):
        r"""open(IntervalPrice self) -> Real"""
        return _QuantLib.IntervalPrice_open(self)

    def close(self):
        r"""close(IntervalPrice self) -> Real"""
        return _QuantLib.IntervalPrice_close(self)

    def high(self):
        r"""high(IntervalPrice self) -> Real"""
        return _QuantLib.IntervalPrice_high(self)

    def low(self):
        r"""low(IntervalPrice self) -> Real"""
        return _QuantLib.IntervalPrice_low(self)

    @staticmethod
    def makeSeries(d, open, close, high, low):
        r"""makeSeries(DateVector d, DoubleVector open, DoubleVector close, DoubleVector high, DoubleVector low) -> IntervalPriceTimeSeries"""
        return _QuantLib.IntervalPrice_makeSeries(d, open, close, high, low)

    @staticmethod
    def extractValues(arg1, t):
        r"""extractValues(IntervalPriceTimeSeries arg1, IntervalPrice::Type t) -> DoubleVector"""
        return _QuantLib.IntervalPrice_extractValues(arg1, t)

    @staticmethod
    def extractComponent(arg1, t):
        r"""extractComponent(IntervalPriceTimeSeries arg1, IntervalPrice::Type t) -> RealTimeSeries"""
        return _QuantLib.IntervalPrice_extractComponent(arg1, t)
    __swig_destroy__ = _QuantLib.delete_IntervalPrice

# Register IntervalPrice in _QuantLib:
_QuantLib.IntervalPrice_swigregister(IntervalPrice)
class IndexManager(object):
    r"""Proxy of C++ IndexManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def instance():
        r"""instance() -> IndexManager"""
        return _QuantLib.IndexManager_instance()

    def setHistory(self, name, fixings):
        r"""setHistory(IndexManager self, std::string const & name, RealTimeSeries fixings)"""
        return _QuantLib.IndexManager_setHistory(self, name, fixings)

    def getHistory(self, name):
        r"""getHistory(IndexManager self, std::string const & name) -> RealTimeSeries"""
        return _QuantLib.IndexManager_getHistory(self, name)

    def hasHistory(self, name):
        r"""hasHistory(IndexManager self, std::string const & name) -> bool"""
        return _QuantLib.IndexManager_hasHistory(self, name)

    def histories(self):
        r"""histories(IndexManager self) -> StrVector"""
        return _QuantLib.IndexManager_histories(self)

    def clearHistory(self, name):
        r"""clearHistory(IndexManager self, std::string const & name)"""
        return _QuantLib.IndexManager_clearHistory(self, name)

    def clearHistories(self):
        r"""clearHistories(IndexManager self)"""
        return _QuantLib.IndexManager_clearHistories(self)

    def hasHistoricalFixing(self, name, fixingDate):
        r"""hasHistoricalFixing(IndexManager self, std::string const & name, Date fixingDate) -> bool"""
        return _QuantLib.IndexManager_hasHistoricalFixing(self, name, fixingDate)
    __swig_destroy__ = _QuantLib.delete_IndexManager

# Register IndexManager in _QuantLib:
_QuantLib.IndexManager_swigregister(IndexManager)
class Index(Observable):
    r"""Proxy of C++ Index class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def name(self):
        r"""name(Index self) -> std::string"""
        return _QuantLib.Index_name(self)

    def fixingCalendar(self):
        r"""fixingCalendar(Index self) -> Calendar"""
        return _QuantLib.Index_fixingCalendar(self)

    def isValidFixingDate(self, fixingDate):
        r"""isValidFixingDate(Index self, Date fixingDate) -> bool"""
        return _QuantLib.Index_isValidFixingDate(self, fixingDate)

    def hasHistoricalFixing(self, fixingDate):
        r"""hasHistoricalFixing(Index self, Date fixingDate) -> bool"""
        return _QuantLib.Index_hasHistoricalFixing(self, fixingDate)

    def fixing(self, fixingDate, forecastTodaysFixing=False):
        r"""fixing(Index self, Date fixingDate, bool forecastTodaysFixing=False) -> Real"""
        return _QuantLib.Index_fixing(self, fixingDate, forecastTodaysFixing)

    def addFixing(self, fixingDate, fixing, forceOverwrite=False):
        r"""addFixing(Index self, Date fixingDate, Rate fixing, bool forceOverwrite=False)"""
        return _QuantLib.Index_addFixing(self, fixingDate, fixing, forceOverwrite)

    def timeSeries(self):
        r"""timeSeries(Index self) -> RealTimeSeries"""
        return _QuantLib.Index_timeSeries(self)

    def clearFixings(self):
        r"""clearFixings(Index self)"""
        return _QuantLib.Index_clearFixings(self)

    def addFixings(self, fixingDates, fixings, forceOverwrite=False):
        r"""addFixings(Index self, DateVector fixingDates, DoubleVector fixings, bool forceOverwrite=False)"""
        return _QuantLib.Index_addFixings(self, fixingDates, fixings, forceOverwrite)

    def __str__(self):
        r"""__str__(Index self) -> std::string"""
        return _QuantLib.Index___str__(self)
    __swig_destroy__ = _QuantLib.delete_Index

# Register Index in _QuantLib:
_QuantLib.Index_swigregister(Index)
class InterestRateIndex(Index):
    r"""Proxy of C++ InterestRateIndex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def familyName(self):
        r"""familyName(InterestRateIndex self) -> std::string"""
        return _QuantLib.InterestRateIndex_familyName(self)

    def tenor(self):
        r"""tenor(InterestRateIndex self) -> Period"""
        return _QuantLib.InterestRateIndex_tenor(self)

    def fixingDays(self):
        r"""fixingDays(InterestRateIndex self) -> Natural"""
        return _QuantLib.InterestRateIndex_fixingDays(self)

    def fixingDate(self, valueDate):
        r"""fixingDate(InterestRateIndex self, Date valueDate) -> Date"""
        return _QuantLib.InterestRateIndex_fixingDate(self, valueDate)

    def currency(self):
        r"""currency(InterestRateIndex self) -> Currency"""
        return _QuantLib.InterestRateIndex_currency(self)

    def dayCounter(self):
        r"""dayCounter(InterestRateIndex self) -> DayCounter"""
        return _QuantLib.InterestRateIndex_dayCounter(self)

    def maturityDate(self, valueDate):
        r"""maturityDate(InterestRateIndex self, Date valueDate) -> Date"""
        return _QuantLib.InterestRateIndex_maturityDate(self, valueDate)

    def valueDate(self, fixingDate):
        r"""valueDate(InterestRateIndex self, Date fixingDate) -> Date"""
        return _QuantLib.InterestRateIndex_valueDate(self, fixingDate)
    __swig_destroy__ = _QuantLib.delete_InterestRateIndex

# Register InterestRateIndex in _QuantLib:
_QuantLib.InterestRateIndex_swigregister(InterestRateIndex)
class IborIndex(InterestRateIndex):
    r"""Proxy of C++ IborIndex class."""

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

    def __init__(self, *args):
        r"""__init__(IborIndex self, std::string const & familyName, Period tenor, Integer settlementDays, Currency currency, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> IborIndex"""
        _QuantLib.IborIndex_swiginit(self, _QuantLib.new_IborIndex(*args))

    def businessDayConvention(self):
        r"""businessDayConvention(IborIndex self) -> BusinessDayConvention"""
        return _QuantLib.IborIndex_businessDayConvention(self)

    def endOfMonth(self):
        r"""endOfMonth(IborIndex self) -> bool"""
        return _QuantLib.IborIndex_endOfMonth(self)

    def forwardingTermStructure(self):
        r"""forwardingTermStructure(IborIndex self) -> YieldTermStructureHandle"""
        return _QuantLib.IborIndex_forwardingTermStructure(self)

    def clone(self, arg2):
        r"""clone(IborIndex self, YieldTermStructureHandle arg2) -> ext::shared_ptr< IborIndex >"""
        return _QuantLib.IborIndex_clone(self, arg2)
    __swig_destroy__ = _QuantLib.delete_IborIndex

# Register IborIndex in _QuantLib:
_QuantLib.IborIndex_swigregister(IborIndex)

def as_iborindex(index):
    r"""as_iborindex(ext::shared_ptr< InterestRateIndex > const & index) -> ext::shared_ptr< IborIndex >"""
    return _QuantLib.as_iborindex(index)
class OvernightIndex(IborIndex):
    r"""Proxy of C++ OvernightIndex class."""

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

    def __init__(self, *args):
        r"""__init__(OvernightIndex self, std::string const & familyName, Integer settlementDays, Currency currency, Calendar calendar, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> OvernightIndex"""
        _QuantLib.OvernightIndex_swiginit(self, _QuantLib.new_OvernightIndex(*args))

    def clone(self, h):
        r"""clone(OvernightIndex self, YieldTermStructureHandle h) -> ext::shared_ptr< OvernightIndex >"""
        return _QuantLib.OvernightIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_OvernightIndex

# Register OvernightIndex in _QuantLib:
_QuantLib.OvernightIndex_swigregister(OvernightIndex)
class Libor(IborIndex):
    r"""Proxy of C++ Libor class."""

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

    def __init__(self, *args):
        r"""__init__(Libor self, std::string const & familyName, Period tenor, Natural settlementDays, Currency currency, Calendar financialCenterCalendar, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Libor"""
        _QuantLib.Libor_swiginit(self, _QuantLib.new_Libor(*args))
    __swig_destroy__ = _QuantLib.delete_Libor

# Register Libor in _QuantLib:
_QuantLib.Libor_swigregister(Libor)
class DailyTenorLibor(IborIndex):
    r"""Proxy of C++ DailyTenorLibor class."""

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

    def __init__(self, *args):
        r"""__init__(DailyTenorLibor self, std::string const & familyName, Natural settlementDays, Currency currency, Calendar financialCenterCalendar, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> DailyTenorLibor"""
        _QuantLib.DailyTenorLibor_swiginit(self, _QuantLib.new_DailyTenorLibor(*args))
    __swig_destroy__ = _QuantLib.delete_DailyTenorLibor

# Register DailyTenorLibor in _QuantLib:
_QuantLib.DailyTenorLibor_swigregister(DailyTenorLibor)
class SwapIndex(InterestRateIndex):
    r"""Proxy of C++ SwapIndex class."""

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

    def __init__(self, *args):
        r"""
        __init__(SwapIndex self, std::string const & familyName, Period tenor, Integer settlementDays, Currency currency, Calendar calendar, Period fixedLegTenor, BusinessDayConvention fixedLegConvention, DayCounter fixedLegDayCounter, ext::shared_ptr< IborIndex > const & iborIndex) -> SwapIndex
        __init__(SwapIndex self, std::string const & familyName, Period tenor, Integer settlementDays, Currency currency, Calendar calendar, Period fixedLegTenor, BusinessDayConvention fixedLegConvention, DayCounter fixedLegDayCounter, ext::shared_ptr< IborIndex > const & iborIndex, YieldTermStructureHandle discountCurve) -> SwapIndex
        """
        _QuantLib.SwapIndex_swiginit(self, _QuantLib.new_SwapIndex(*args))

    def fixedLegTenor(self):
        r"""fixedLegTenor(SwapIndex self) -> Period"""
        return _QuantLib.SwapIndex_fixedLegTenor(self)

    def fixedLegConvention(self):
        r"""fixedLegConvention(SwapIndex self) -> BusinessDayConvention"""
        return _QuantLib.SwapIndex_fixedLegConvention(self)

    def iborIndex(self):
        r"""iborIndex(SwapIndex self) -> ext::shared_ptr< IborIndex >"""
        return _QuantLib.SwapIndex_iborIndex(self)

    def forwardingTermStructure(self):
        r"""forwardingTermStructure(SwapIndex self) -> YieldTermStructureHandle"""
        return _QuantLib.SwapIndex_forwardingTermStructure(self)

    def discountingTermStructure(self):
        r"""discountingTermStructure(SwapIndex self) -> YieldTermStructureHandle"""
        return _QuantLib.SwapIndex_discountingTermStructure(self)

    def clone(self, *args):
        r"""
        clone(SwapIndex self, YieldTermStructureHandle h) -> ext::shared_ptr< SwapIndex >
        clone(SwapIndex self, YieldTermStructureHandle forwarding, YieldTermStructureHandle discounting) -> ext::shared_ptr< SwapIndex >
        clone(SwapIndex self, Period tenor) -> ext::shared_ptr< SwapIndex >
        """
        return _QuantLib.SwapIndex_clone(self, *args)
    __swig_destroy__ = _QuantLib.delete_SwapIndex

# Register SwapIndex in _QuantLib:
_QuantLib.SwapIndex_swigregister(SwapIndex)
class SwapIndexVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< SwapIndex > > class."""

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

    def iterator(self):
        r"""iterator(SwapIndexVector self) -> SwigPyIterator"""
        return _QuantLib.SwapIndexVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(SwapIndexVector self) -> bool"""
        return _QuantLib.SwapIndexVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(SwapIndexVector self) -> bool"""
        return _QuantLib.SwapIndexVector___bool__(self)

    def __len__(self):
        r"""__len__(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::size_type"""
        return _QuantLib.SwapIndexVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j) -> SwapIndexVector"""
        return _QuantLib.SwapIndexVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j)
        __setslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j, SwapIndexVector v)
        """
        return _QuantLib.SwapIndexVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j)"""
        return _QuantLib.SwapIndexVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i)
        __delitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.SwapIndexVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice) -> SwapIndexVector
        __getitem__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type const &
        """
        return _QuantLib.SwapIndexVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice, SwapIndexVector v)
        __setitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)
        """
        return _QuantLib.SwapIndexVector___setitem__(self, *args)

    def pop(self):
        r"""pop(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type"""
        return _QuantLib.SwapIndexVector_pop(self)

    def append(self, x):
        r"""append(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)"""
        return _QuantLib.SwapIndexVector_append(self, x)

    def empty(self):
        r"""empty(SwapIndexVector self) -> bool"""
        return _QuantLib.SwapIndexVector_empty(self)

    def size(self):
        r"""size(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::size_type"""
        return _QuantLib.SwapIndexVector_size(self)

    def swap(self, v):
        r"""swap(SwapIndexVector self, SwapIndexVector v)"""
        return _QuantLib.SwapIndexVector_swap(self, v)

    def begin(self):
        r"""begin(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator"""
        return _QuantLib.SwapIndexVector_begin(self)

    def end(self):
        r"""end(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator"""
        return _QuantLib.SwapIndexVector_end(self)

    def rbegin(self):
        r"""rbegin(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator"""
        return _QuantLib.SwapIndexVector_rbegin(self)

    def rend(self):
        r"""rend(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator"""
        return _QuantLib.SwapIndexVector_rend(self)

    def clear(self):
        r"""clear(SwapIndexVector self)"""
        return _QuantLib.SwapIndexVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::allocator_type"""
        return _QuantLib.SwapIndexVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(SwapIndexVector self)"""
        return _QuantLib.SwapIndexVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator pos) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator
        erase(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator first, std::vector< ext::shared_ptr< SwapIndex > >::iterator last) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator
        """
        return _QuantLib.SwapIndexVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(SwapIndexVector self) -> SwapIndexVector
        __init__(SwapIndexVector self, SwapIndexVector other) -> SwapIndexVector
        __init__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type size) -> SwapIndexVector
        __init__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type size, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & value) -> SwapIndexVector
        """
        _QuantLib.SwapIndexVector_swiginit(self, _QuantLib.new_SwapIndexVector(*args))

    def push_back(self, x):
        r"""push_back(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)"""
        return _QuantLib.SwapIndexVector_push_back(self, x)

    def front(self):
        r"""front(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type const &"""
        return _QuantLib.SwapIndexVector_front(self)

    def back(self):
        r"""back(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type const &"""
        return _QuantLib.SwapIndexVector_back(self)

    def assign(self, n, x):
        r"""assign(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type n, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)"""
        return _QuantLib.SwapIndexVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type new_size)
        resize(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type new_size, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)
        """
        return _QuantLib.SwapIndexVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator pos, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator
        insert(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator pos, std::vector< ext::shared_ptr< SwapIndex > >::size_type n, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)
        """
        return _QuantLib.SwapIndexVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type n)"""
        return _QuantLib.SwapIndexVector_reserve(self, n)

    def capacity(self):
        r"""capacity(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::size_type"""
        return _QuantLib.SwapIndexVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_SwapIndexVector

# Register SwapIndexVector in _QuantLib:
_QuantLib.SwapIndexVector_swigregister(SwapIndexVector)

def as_swap_index(index):
    r"""as_swap_index(ext::shared_ptr< InterestRateIndex > const & index) -> ext::shared_ptr< SwapIndex >"""
    return _QuantLib.as_swap_index(index)
class SwapSpreadIndex(InterestRateIndex):
    r"""Proxy of C++ SwapSpreadIndex class."""

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

    def __init__(self, familyName, swapIndex1, swapIndex2, gearing1=1.0, gearing2=-1.0):
        r"""__init__(SwapSpreadIndex self, std::string const & familyName, ext::shared_ptr< SwapIndex > const & swapIndex1, ext::shared_ptr< SwapIndex > const & swapIndex2, Real const gearing1=1.0, Real const gearing2=-1.0) -> SwapSpreadIndex"""
        _QuantLib.SwapSpreadIndex_swiginit(self, _QuantLib.new_SwapSpreadIndex(familyName, swapIndex1, swapIndex2, gearing1, gearing2))

    def forecastFixing(self, fixingDate):
        r"""forecastFixing(SwapSpreadIndex self, Date fixingDate) -> Rate"""
        return _QuantLib.SwapSpreadIndex_forecastFixing(self, fixingDate)

    def pastFixing(self, fixingDate):
        r"""pastFixing(SwapSpreadIndex self, Date fixingDate) -> Rate"""
        return _QuantLib.SwapSpreadIndex_pastFixing(self, fixingDate)

    def swapIndex1(self):
        r"""swapIndex1(SwapSpreadIndex self) -> ext::shared_ptr< SwapIndex >"""
        return _QuantLib.SwapSpreadIndex_swapIndex1(self)

    def swapIndex2(self):
        r"""swapIndex2(SwapSpreadIndex self) -> ext::shared_ptr< SwapIndex >"""
        return _QuantLib.SwapSpreadIndex_swapIndex2(self)

    def gearing1(self):
        r"""gearing1(SwapSpreadIndex self) -> Real"""
        return _QuantLib.SwapSpreadIndex_gearing1(self)

    def gearing2(self):
        r"""gearing2(SwapSpreadIndex self) -> Real"""
        return _QuantLib.SwapSpreadIndex_gearing2(self)
    __swig_destroy__ = _QuantLib.delete_SwapSpreadIndex

# Register SwapSpreadIndex in _QuantLib:
_QuantLib.SwapSpreadIndex_swigregister(SwapSpreadIndex)
class AUDLibor(IborIndex):
    r"""Proxy of C++ AUDLibor class."""

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

    def __init__(self, *args):
        r"""__init__(AUDLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> AUDLibor"""
        _QuantLib.AUDLibor_swiginit(self, _QuantLib.new_AUDLibor(*args))
    __swig_destroy__ = _QuantLib.delete_AUDLibor

# Register AUDLibor in _QuantLib:
_QuantLib.AUDLibor_swigregister(AUDLibor)
class CADLibor(IborIndex):
    r"""Proxy of C++ CADLibor class."""

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

    def __init__(self, *args):
        r"""__init__(CADLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> CADLibor"""
        _QuantLib.CADLibor_swiginit(self, _QuantLib.new_CADLibor(*args))
    __swig_destroy__ = _QuantLib.delete_CADLibor

# Register CADLibor in _QuantLib:
_QuantLib.CADLibor_swigregister(CADLibor)
class CADLiborON(DailyTenorLibor):
    r"""Proxy of C++ CADLiborON class."""

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

    def __init__(self, *args):
        r"""__init__(CADLiborON self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> CADLiborON"""
        _QuantLib.CADLiborON_swiginit(self, _QuantLib.new_CADLiborON(*args))
    __swig_destroy__ = _QuantLib.delete_CADLiborON

# Register CADLiborON in _QuantLib:
_QuantLib.CADLiborON_swigregister(CADLiborON)
class Cdor(IborIndex):
    r"""Proxy of C++ Cdor class."""

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

    def __init__(self, *args):
        r"""__init__(Cdor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Cdor"""
        _QuantLib.Cdor_swiginit(self, _QuantLib.new_Cdor(*args))
    __swig_destroy__ = _QuantLib.delete_Cdor

# Register Cdor in _QuantLib:
_QuantLib.Cdor_swigregister(Cdor)
class CHFLibor(IborIndex):
    r"""Proxy of C++ CHFLibor class."""

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

    def __init__(self, *args):
        r"""__init__(CHFLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> CHFLibor"""
        _QuantLib.CHFLibor_swiginit(self, _QuantLib.new_CHFLibor(*args))
    __swig_destroy__ = _QuantLib.delete_CHFLibor

# Register CHFLibor in _QuantLib:
_QuantLib.CHFLibor_swigregister(CHFLibor)
class DKKLibor(IborIndex):
    r"""Proxy of C++ DKKLibor class."""

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

    def __init__(self, *args):
        r"""__init__(DKKLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> DKKLibor"""
        _QuantLib.DKKLibor_swiginit(self, _QuantLib.new_DKKLibor(*args))
    __swig_destroy__ = _QuantLib.delete_DKKLibor

# Register DKKLibor in _QuantLib:
_QuantLib.DKKLibor_swigregister(DKKLibor)
class Bbsw(IborIndex):
    r"""Proxy of C++ Bbsw class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw"""
        _QuantLib.Bbsw_swiginit(self, _QuantLib.new_Bbsw(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw

# Register Bbsw in _QuantLib:
_QuantLib.Bbsw_swigregister(Bbsw)
class Bbsw1M(Bbsw):
    r"""Proxy of C++ Bbsw1M class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw1M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw1M"""
        _QuantLib.Bbsw1M_swiginit(self, _QuantLib.new_Bbsw1M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw1M

# Register Bbsw1M in _QuantLib:
_QuantLib.Bbsw1M_swigregister(Bbsw1M)
class Bbsw2M(Bbsw):
    r"""Proxy of C++ Bbsw2M class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw2M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw2M"""
        _QuantLib.Bbsw2M_swiginit(self, _QuantLib.new_Bbsw2M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw2M

# Register Bbsw2M in _QuantLib:
_QuantLib.Bbsw2M_swigregister(Bbsw2M)
class Bbsw3M(Bbsw):
    r"""Proxy of C++ Bbsw3M class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw3M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw3M"""
        _QuantLib.Bbsw3M_swiginit(self, _QuantLib.new_Bbsw3M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw3M

# Register Bbsw3M in _QuantLib:
_QuantLib.Bbsw3M_swigregister(Bbsw3M)
class Bbsw4M(Bbsw):
    r"""Proxy of C++ Bbsw4M class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw4M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw4M"""
        _QuantLib.Bbsw4M_swiginit(self, _QuantLib.new_Bbsw4M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw4M

# Register Bbsw4M in _QuantLib:
_QuantLib.Bbsw4M_swigregister(Bbsw4M)
class Bbsw5M(Bbsw):
    r"""Proxy of C++ Bbsw5M class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw5M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw5M"""
        _QuantLib.Bbsw5M_swiginit(self, _QuantLib.new_Bbsw5M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw5M

# Register Bbsw5M in _QuantLib:
_QuantLib.Bbsw5M_swigregister(Bbsw5M)
class Bbsw6M(Bbsw):
    r"""Proxy of C++ Bbsw6M class."""

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

    def __init__(self, *args):
        r"""__init__(Bbsw6M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bbsw6M"""
        _QuantLib.Bbsw6M_swiginit(self, _QuantLib.new_Bbsw6M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw6M

# Register Bbsw6M in _QuantLib:
_QuantLib.Bbsw6M_swigregister(Bbsw6M)
class Bkbm(IborIndex):
    r"""Proxy of C++ Bkbm class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm"""
        _QuantLib.Bkbm_swiginit(self, _QuantLib.new_Bkbm(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm

# Register Bkbm in _QuantLib:
_QuantLib.Bkbm_swigregister(Bkbm)
class Bkbm1M(Bkbm):
    r"""Proxy of C++ Bkbm1M class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm1M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm1M"""
        _QuantLib.Bkbm1M_swiginit(self, _QuantLib.new_Bkbm1M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm1M

# Register Bkbm1M in _QuantLib:
_QuantLib.Bkbm1M_swigregister(Bkbm1M)
class Bkbm2M(Bkbm):
    r"""Proxy of C++ Bkbm2M class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm2M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm2M"""
        _QuantLib.Bkbm2M_swiginit(self, _QuantLib.new_Bkbm2M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm2M

# Register Bkbm2M in _QuantLib:
_QuantLib.Bkbm2M_swigregister(Bkbm2M)
class Bkbm3M(Bkbm):
    r"""Proxy of C++ Bkbm3M class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm3M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm3M"""
        _QuantLib.Bkbm3M_swiginit(self, _QuantLib.new_Bkbm3M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm3M

# Register Bkbm3M in _QuantLib:
_QuantLib.Bkbm3M_swigregister(Bkbm3M)
class Bkbm4M(Bkbm):
    r"""Proxy of C++ Bkbm4M class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm4M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm4M"""
        _QuantLib.Bkbm4M_swiginit(self, _QuantLib.new_Bkbm4M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm4M

# Register Bkbm4M in _QuantLib:
_QuantLib.Bkbm4M_swigregister(Bkbm4M)
class Bkbm5M(Bkbm):
    r"""Proxy of C++ Bkbm5M class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm5M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm5M"""
        _QuantLib.Bkbm5M_swiginit(self, _QuantLib.new_Bkbm5M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm5M

# Register Bkbm5M in _QuantLib:
_QuantLib.Bkbm5M_swigregister(Bkbm5M)
class Bkbm6M(Bkbm):
    r"""Proxy of C++ Bkbm6M class."""

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

    def __init__(self, *args):
        r"""__init__(Bkbm6M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bkbm6M"""
        _QuantLib.Bkbm6M_swiginit(self, _QuantLib.new_Bkbm6M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm6M

# Register Bkbm6M in _QuantLib:
_QuantLib.Bkbm6M_swigregister(Bkbm6M)
class Euribor(IborIndex):
    r"""Proxy of C++ Euribor class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor"""
        _QuantLib.Euribor_swiginit(self, _QuantLib.new_Euribor(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor

# Register Euribor in _QuantLib:
_QuantLib.Euribor_swigregister(Euribor)
class EuriborSW(Euribor):
    r"""Proxy of C++ EuriborSW class."""

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

    def __init__(self, *args):
        r"""__init__(EuriborSW self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EuriborSW"""
        _QuantLib.EuriborSW_swiginit(self, _QuantLib.new_EuriborSW(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSW

# Register EuriborSW in _QuantLib:
_QuantLib.EuriborSW_swigregister(EuriborSW)
class Euribor2W(Euribor):
    r"""Proxy of C++ Euribor2W class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor2W self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor2W"""
        _QuantLib.Euribor2W_swiginit(self, _QuantLib.new_Euribor2W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor2W

# Register Euribor2W in _QuantLib:
_QuantLib.Euribor2W_swigregister(Euribor2W)
class Euribor3W(Euribor):
    r"""Proxy of C++ Euribor3W class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor3W self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor3W"""
        _QuantLib.Euribor3W_swiginit(self, _QuantLib.new_Euribor3W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor3W

# Register Euribor3W in _QuantLib:
_QuantLib.Euribor3W_swigregister(Euribor3W)
class Euribor1M(Euribor):
    r"""Proxy of C++ Euribor1M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor1M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor1M"""
        _QuantLib.Euribor1M_swiginit(self, _QuantLib.new_Euribor1M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor1M

# Register Euribor1M in _QuantLib:
_QuantLib.Euribor1M_swigregister(Euribor1M)
class Euribor2M(Euribor):
    r"""Proxy of C++ Euribor2M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor2M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor2M"""
        _QuantLib.Euribor2M_swiginit(self, _QuantLib.new_Euribor2M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor2M

# Register Euribor2M in _QuantLib:
_QuantLib.Euribor2M_swigregister(Euribor2M)
class Euribor3M(Euribor):
    r"""Proxy of C++ Euribor3M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor3M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor3M"""
        _QuantLib.Euribor3M_swiginit(self, _QuantLib.new_Euribor3M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor3M

# Register Euribor3M in _QuantLib:
_QuantLib.Euribor3M_swigregister(Euribor3M)
class Euribor4M(Euribor):
    r"""Proxy of C++ Euribor4M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor4M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor4M"""
        _QuantLib.Euribor4M_swiginit(self, _QuantLib.new_Euribor4M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor4M

# Register Euribor4M in _QuantLib:
_QuantLib.Euribor4M_swigregister(Euribor4M)
class Euribor5M(Euribor):
    r"""Proxy of C++ Euribor5M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor5M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor5M"""
        _QuantLib.Euribor5M_swiginit(self, _QuantLib.new_Euribor5M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor5M

# Register Euribor5M in _QuantLib:
_QuantLib.Euribor5M_swigregister(Euribor5M)
class Euribor6M(Euribor):
    r"""Proxy of C++ Euribor6M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor6M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor6M"""
        _QuantLib.Euribor6M_swiginit(self, _QuantLib.new_Euribor6M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor6M

# Register Euribor6M in _QuantLib:
_QuantLib.Euribor6M_swigregister(Euribor6M)
class Euribor7M(Euribor):
    r"""Proxy of C++ Euribor7M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor7M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor7M"""
        _QuantLib.Euribor7M_swiginit(self, _QuantLib.new_Euribor7M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor7M

# Register Euribor7M in _QuantLib:
_QuantLib.Euribor7M_swigregister(Euribor7M)
class Euribor8M(Euribor):
    r"""Proxy of C++ Euribor8M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor8M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor8M"""
        _QuantLib.Euribor8M_swiginit(self, _QuantLib.new_Euribor8M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor8M

# Register Euribor8M in _QuantLib:
_QuantLib.Euribor8M_swigregister(Euribor8M)
class Euribor9M(Euribor):
    r"""Proxy of C++ Euribor9M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor9M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor9M"""
        _QuantLib.Euribor9M_swiginit(self, _QuantLib.new_Euribor9M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor9M

# Register Euribor9M in _QuantLib:
_QuantLib.Euribor9M_swigregister(Euribor9M)
class Euribor10M(Euribor):
    r"""Proxy of C++ Euribor10M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor10M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor10M"""
        _QuantLib.Euribor10M_swiginit(self, _QuantLib.new_Euribor10M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor10M

# Register Euribor10M in _QuantLib:
_QuantLib.Euribor10M_swigregister(Euribor10M)
class Euribor11M(Euribor):
    r"""Proxy of C++ Euribor11M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor11M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor11M"""
        _QuantLib.Euribor11M_swiginit(self, _QuantLib.new_Euribor11M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor11M

# Register Euribor11M in _QuantLib:
_QuantLib.Euribor11M_swigregister(Euribor11M)
class Euribor1Y(Euribor):
    r"""Proxy of C++ Euribor1Y class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor1Y self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor1Y"""
        _QuantLib.Euribor1Y_swiginit(self, _QuantLib.new_Euribor1Y(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor1Y

# Register Euribor1Y in _QuantLib:
_QuantLib.Euribor1Y_swigregister(Euribor1Y)
class Euribor365(IborIndex):
    r"""Proxy of C++ Euribor365 class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365 self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365"""
        _QuantLib.Euribor365_swiginit(self, _QuantLib.new_Euribor365(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365

# Register Euribor365 in _QuantLib:
_QuantLib.Euribor365_swigregister(Euribor365)
class Euribor365_SW(Euribor365):
    r"""Proxy of C++ Euribor365_SW class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_SW self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_SW"""
        _QuantLib.Euribor365_SW_swiginit(self, _QuantLib.new_Euribor365_SW(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_SW

# Register Euribor365_SW in _QuantLib:
_QuantLib.Euribor365_SW_swigregister(Euribor365_SW)
class Euribor365_2W(Euribor365):
    r"""Proxy of C++ Euribor365_2W class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_2W self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_2W"""
        _QuantLib.Euribor365_2W_swiginit(self, _QuantLib.new_Euribor365_2W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_2W

# Register Euribor365_2W in _QuantLib:
_QuantLib.Euribor365_2W_swigregister(Euribor365_2W)
class Euribor365_3W(Euribor365):
    r"""Proxy of C++ Euribor365_3W class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_3W self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_3W"""
        _QuantLib.Euribor365_3W_swiginit(self, _QuantLib.new_Euribor365_3W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_3W

# Register Euribor365_3W in _QuantLib:
_QuantLib.Euribor365_3W_swigregister(Euribor365_3W)
class Euribor365_1M(Euribor365):
    r"""Proxy of C++ Euribor365_1M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_1M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_1M"""
        _QuantLib.Euribor365_1M_swiginit(self, _QuantLib.new_Euribor365_1M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_1M

# Register Euribor365_1M in _QuantLib:
_QuantLib.Euribor365_1M_swigregister(Euribor365_1M)
class Euribor365_2M(Euribor365):
    r"""Proxy of C++ Euribor365_2M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_2M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_2M"""
        _QuantLib.Euribor365_2M_swiginit(self, _QuantLib.new_Euribor365_2M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_2M

# Register Euribor365_2M in _QuantLib:
_QuantLib.Euribor365_2M_swigregister(Euribor365_2M)
class Euribor365_3M(Euribor365):
    r"""Proxy of C++ Euribor365_3M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_3M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_3M"""
        _QuantLib.Euribor365_3M_swiginit(self, _QuantLib.new_Euribor365_3M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_3M

# Register Euribor365_3M in _QuantLib:
_QuantLib.Euribor365_3M_swigregister(Euribor365_3M)
class Euribor365_4M(Euribor365):
    r"""Proxy of C++ Euribor365_4M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_4M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_4M"""
        _QuantLib.Euribor365_4M_swiginit(self, _QuantLib.new_Euribor365_4M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_4M

# Register Euribor365_4M in _QuantLib:
_QuantLib.Euribor365_4M_swigregister(Euribor365_4M)
class Euribor365_5M(Euribor365):
    r"""Proxy of C++ Euribor365_5M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_5M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_5M"""
        _QuantLib.Euribor365_5M_swiginit(self, _QuantLib.new_Euribor365_5M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_5M

# Register Euribor365_5M in _QuantLib:
_QuantLib.Euribor365_5M_swigregister(Euribor365_5M)
class Euribor365_6M(Euribor365):
    r"""Proxy of C++ Euribor365_6M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_6M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_6M"""
        _QuantLib.Euribor365_6M_swiginit(self, _QuantLib.new_Euribor365_6M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_6M

# Register Euribor365_6M in _QuantLib:
_QuantLib.Euribor365_6M_swigregister(Euribor365_6M)
class Euribor365_7M(Euribor365):
    r"""Proxy of C++ Euribor365_7M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_7M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_7M"""
        _QuantLib.Euribor365_7M_swiginit(self, _QuantLib.new_Euribor365_7M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_7M

# Register Euribor365_7M in _QuantLib:
_QuantLib.Euribor365_7M_swigregister(Euribor365_7M)
class Euribor365_8M(Euribor365):
    r"""Proxy of C++ Euribor365_8M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_8M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_8M"""
        _QuantLib.Euribor365_8M_swiginit(self, _QuantLib.new_Euribor365_8M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_8M

# Register Euribor365_8M in _QuantLib:
_QuantLib.Euribor365_8M_swigregister(Euribor365_8M)
class Euribor365_9M(Euribor365):
    r"""Proxy of C++ Euribor365_9M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_9M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_9M"""
        _QuantLib.Euribor365_9M_swiginit(self, _QuantLib.new_Euribor365_9M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_9M

# Register Euribor365_9M in _QuantLib:
_QuantLib.Euribor365_9M_swigregister(Euribor365_9M)
class Euribor365_10M(Euribor365):
    r"""Proxy of C++ Euribor365_10M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_10M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_10M"""
        _QuantLib.Euribor365_10M_swiginit(self, _QuantLib.new_Euribor365_10M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_10M

# Register Euribor365_10M in _QuantLib:
_QuantLib.Euribor365_10M_swigregister(Euribor365_10M)
class Euribor365_11M(Euribor365):
    r"""Proxy of C++ Euribor365_11M class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_11M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_11M"""
        _QuantLib.Euribor365_11M_swiginit(self, _QuantLib.new_Euribor365_11M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_11M

# Register Euribor365_11M in _QuantLib:
_QuantLib.Euribor365_11M_swigregister(Euribor365_11M)
class Euribor365_1Y(Euribor365):
    r"""Proxy of C++ Euribor365_1Y class."""

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

    def __init__(self, *args):
        r"""__init__(Euribor365_1Y self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Euribor365_1Y"""
        _QuantLib.Euribor365_1Y_swiginit(self, _QuantLib.new_Euribor365_1Y(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_1Y

# Register Euribor365_1Y in _QuantLib:
_QuantLib.Euribor365_1Y_swigregister(Euribor365_1Y)
class EURLibor(IborIndex):
    r"""Proxy of C++ EURLibor class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor"""
        _QuantLib.EURLibor_swiginit(self, _QuantLib.new_EURLibor(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor

# Register EURLibor in _QuantLib:
_QuantLib.EURLibor_swigregister(EURLibor)
class EURLiborSW(EURLibor):
    r"""Proxy of C++ EURLiborSW class."""

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

    def __init__(self, *args):
        r"""__init__(EURLiborSW self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLiborSW"""
        _QuantLib.EURLiborSW_swiginit(self, _QuantLib.new_EURLiborSW(*args))
    __swig_destroy__ = _QuantLib.delete_EURLiborSW

# Register EURLiborSW in _QuantLib:
_QuantLib.EURLiborSW_swigregister(EURLiborSW)
class EURLibor2W(EURLibor):
    r"""Proxy of C++ EURLibor2W class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor2W self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor2W"""
        _QuantLib.EURLibor2W_swiginit(self, _QuantLib.new_EURLibor2W(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor2W

# Register EURLibor2W in _QuantLib:
_QuantLib.EURLibor2W_swigregister(EURLibor2W)
class EURLibor1M(EURLibor):
    r"""Proxy of C++ EURLibor1M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor1M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor1M"""
        _QuantLib.EURLibor1M_swiginit(self, _QuantLib.new_EURLibor1M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor1M

# Register EURLibor1M in _QuantLib:
_QuantLib.EURLibor1M_swigregister(EURLibor1M)
class EURLibor2M(EURLibor):
    r"""Proxy of C++ EURLibor2M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor2M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor2M"""
        _QuantLib.EURLibor2M_swiginit(self, _QuantLib.new_EURLibor2M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor2M

# Register EURLibor2M in _QuantLib:
_QuantLib.EURLibor2M_swigregister(EURLibor2M)
class EURLibor3M(EURLibor):
    r"""Proxy of C++ EURLibor3M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor3M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor3M"""
        _QuantLib.EURLibor3M_swiginit(self, _QuantLib.new_EURLibor3M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor3M

# Register EURLibor3M in _QuantLib:
_QuantLib.EURLibor3M_swigregister(EURLibor3M)
class EURLibor4M(EURLibor):
    r"""Proxy of C++ EURLibor4M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor4M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor4M"""
        _QuantLib.EURLibor4M_swiginit(self, _QuantLib.new_EURLibor4M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor4M

# Register EURLibor4M in _QuantLib:
_QuantLib.EURLibor4M_swigregister(EURLibor4M)
class EURLibor5M(EURLibor):
    r"""Proxy of C++ EURLibor5M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor5M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor5M"""
        _QuantLib.EURLibor5M_swiginit(self, _QuantLib.new_EURLibor5M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor5M

# Register EURLibor5M in _QuantLib:
_QuantLib.EURLibor5M_swigregister(EURLibor5M)
class EURLibor6M(EURLibor):
    r"""Proxy of C++ EURLibor6M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor6M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor6M"""
        _QuantLib.EURLibor6M_swiginit(self, _QuantLib.new_EURLibor6M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor6M

# Register EURLibor6M in _QuantLib:
_QuantLib.EURLibor6M_swigregister(EURLibor6M)
class EURLibor7M(EURLibor):
    r"""Proxy of C++ EURLibor7M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor7M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor7M"""
        _QuantLib.EURLibor7M_swiginit(self, _QuantLib.new_EURLibor7M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor7M

# Register EURLibor7M in _QuantLib:
_QuantLib.EURLibor7M_swigregister(EURLibor7M)
class EURLibor8M(EURLibor):
    r"""Proxy of C++ EURLibor8M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor8M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor8M"""
        _QuantLib.EURLibor8M_swiginit(self, _QuantLib.new_EURLibor8M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor8M

# Register EURLibor8M in _QuantLib:
_QuantLib.EURLibor8M_swigregister(EURLibor8M)
class EURLibor9M(EURLibor):
    r"""Proxy of C++ EURLibor9M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor9M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor9M"""
        _QuantLib.EURLibor9M_swiginit(self, _QuantLib.new_EURLibor9M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor9M

# Register EURLibor9M in _QuantLib:
_QuantLib.EURLibor9M_swigregister(EURLibor9M)
class EURLibor10M(EURLibor):
    r"""Proxy of C++ EURLibor10M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor10M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor10M"""
        _QuantLib.EURLibor10M_swiginit(self, _QuantLib.new_EURLibor10M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor10M

# Register EURLibor10M in _QuantLib:
_QuantLib.EURLibor10M_swigregister(EURLibor10M)
class EURLibor11M(EURLibor):
    r"""Proxy of C++ EURLibor11M class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor11M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor11M"""
        _QuantLib.EURLibor11M_swiginit(self, _QuantLib.new_EURLibor11M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor11M

# Register EURLibor11M in _QuantLib:
_QuantLib.EURLibor11M_swigregister(EURLibor11M)
class EURLibor1Y(EURLibor):
    r"""Proxy of C++ EURLibor1Y class."""

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

    def __init__(self, *args):
        r"""__init__(EURLibor1Y self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EURLibor1Y"""
        _QuantLib.EURLibor1Y_swiginit(self, _QuantLib.new_EURLibor1Y(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor1Y

# Register EURLibor1Y in _QuantLib:
_QuantLib.EURLibor1Y_swigregister(EURLibor1Y)
class GBPLibor(IborIndex):
    r"""Proxy of C++ GBPLibor class."""

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

    def __init__(self, *args):
        r"""__init__(GBPLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> GBPLibor"""
        _QuantLib.GBPLibor_swiginit(self, _QuantLib.new_GBPLibor(*args))
    __swig_destroy__ = _QuantLib.delete_GBPLibor

# Register GBPLibor in _QuantLib:
_QuantLib.GBPLibor_swigregister(GBPLibor)
class GBPLiborON(DailyTenorLibor):
    r"""Proxy of C++ GBPLiborON class."""

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

    def __init__(self, *args):
        r"""__init__(GBPLiborON self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> GBPLiborON"""
        _QuantLib.GBPLiborON_swiginit(self, _QuantLib.new_GBPLiborON(*args))
    __swig_destroy__ = _QuantLib.delete_GBPLiborON

# Register GBPLiborON in _QuantLib:
_QuantLib.GBPLiborON_swigregister(GBPLiborON)
class Jibar(IborIndex):
    r"""Proxy of C++ Jibar class."""

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

    def __init__(self, *args):
        r"""__init__(Jibar self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Jibar"""
        _QuantLib.Jibar_swiginit(self, _QuantLib.new_Jibar(*args))
    __swig_destroy__ = _QuantLib.delete_Jibar

# Register Jibar in _QuantLib:
_QuantLib.Jibar_swigregister(Jibar)
class JPYLibor(IborIndex):
    r"""Proxy of C++ JPYLibor class."""

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

    def __init__(self, *args):
        r"""__init__(JPYLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> JPYLibor"""
        _QuantLib.JPYLibor_swiginit(self, _QuantLib.new_JPYLibor(*args))
    __swig_destroy__ = _QuantLib.delete_JPYLibor

# Register JPYLibor in _QuantLib:
_QuantLib.JPYLibor_swigregister(JPYLibor)
class Mosprime(IborIndex):
    r"""Proxy of C++ Mosprime class."""

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

    def __init__(self, *args):
        r"""__init__(Mosprime self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Mosprime"""
        _QuantLib.Mosprime_swiginit(self, _QuantLib.new_Mosprime(*args))
    __swig_destroy__ = _QuantLib.delete_Mosprime

# Register Mosprime in _QuantLib:
_QuantLib.Mosprime_swigregister(Mosprime)
class NZDLibor(IborIndex):
    r"""Proxy of C++ NZDLibor class."""

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

    def __init__(self, *args):
        r"""__init__(NZDLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> NZDLibor"""
        _QuantLib.NZDLibor_swiginit(self, _QuantLib.new_NZDLibor(*args))
    __swig_destroy__ = _QuantLib.delete_NZDLibor

# Register NZDLibor in _QuantLib:
_QuantLib.NZDLibor_swigregister(NZDLibor)
class Pribor(IborIndex):
    r"""Proxy of C++ Pribor class."""

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

    def __init__(self, *args):
        r"""__init__(Pribor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Pribor"""
        _QuantLib.Pribor_swiginit(self, _QuantLib.new_Pribor(*args))
    __swig_destroy__ = _QuantLib.delete_Pribor

# Register Pribor in _QuantLib:
_QuantLib.Pribor_swigregister(Pribor)
class Robor(IborIndex):
    r"""Proxy of C++ Robor class."""

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

    def __init__(self, *args):
        r"""__init__(Robor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Robor"""
        _QuantLib.Robor_swiginit(self, _QuantLib.new_Robor(*args))
    __swig_destroy__ = _QuantLib.delete_Robor

# Register Robor in _QuantLib:
_QuantLib.Robor_swigregister(Robor)
class SEKLibor(IborIndex):
    r"""Proxy of C++ SEKLibor class."""

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

    def __init__(self, *args):
        r"""__init__(SEKLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> SEKLibor"""
        _QuantLib.SEKLibor_swiginit(self, _QuantLib.new_SEKLibor(*args))
    __swig_destroy__ = _QuantLib.delete_SEKLibor

# Register SEKLibor in _QuantLib:
_QuantLib.SEKLibor_swigregister(SEKLibor)
class Shibor(IborIndex):
    r"""Proxy of C++ Shibor class."""

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

    def __init__(self, *args):
        r"""__init__(Shibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Shibor"""
        _QuantLib.Shibor_swiginit(self, _QuantLib.new_Shibor(*args))
    __swig_destroy__ = _QuantLib.delete_Shibor

# Register Shibor in _QuantLib:
_QuantLib.Shibor_swigregister(Shibor)
class Tibor(IborIndex):
    r"""Proxy of C++ Tibor class."""

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

    def __init__(self, *args):
        r"""__init__(Tibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Tibor"""
        _QuantLib.Tibor_swiginit(self, _QuantLib.new_Tibor(*args))
    __swig_destroy__ = _QuantLib.delete_Tibor

# Register Tibor in _QuantLib:
_QuantLib.Tibor_swigregister(Tibor)
class THBFIX(IborIndex):
    r"""Proxy of C++ THBFIX class."""

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

    def __init__(self, *args):
        r"""__init__(THBFIX self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> THBFIX"""
        _QuantLib.THBFIX_swiginit(self, _QuantLib.new_THBFIX(*args))
    __swig_destroy__ = _QuantLib.delete_THBFIX

# Register THBFIX in _QuantLib:
_QuantLib.THBFIX_swigregister(THBFIX)
class TRLibor(IborIndex):
    r"""Proxy of C++ TRLibor class."""

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

    def __init__(self, *args):
        r"""__init__(TRLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> TRLibor"""
        _QuantLib.TRLibor_swiginit(self, _QuantLib.new_TRLibor(*args))
    __swig_destroy__ = _QuantLib.delete_TRLibor

# Register TRLibor in _QuantLib:
_QuantLib.TRLibor_swigregister(TRLibor)
class USDLibor(IborIndex):
    r"""Proxy of C++ USDLibor class."""

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

    def __init__(self, *args):
        r"""__init__(USDLibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> USDLibor"""
        _QuantLib.USDLibor_swiginit(self, _QuantLib.new_USDLibor(*args))
    __swig_destroy__ = _QuantLib.delete_USDLibor

# Register USDLibor in _QuantLib:
_QuantLib.USDLibor_swigregister(USDLibor)
class USDLiborON(DailyTenorLibor):
    r"""Proxy of C++ USDLiborON class."""

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

    def __init__(self, *args):
        r"""__init__(USDLiborON self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> USDLiborON"""
        _QuantLib.USDLiborON_swiginit(self, _QuantLib.new_USDLiborON(*args))
    __swig_destroy__ = _QuantLib.delete_USDLiborON

# Register USDLiborON in _QuantLib:
_QuantLib.USDLiborON_swigregister(USDLiborON)
class Wibor(IborIndex):
    r"""Proxy of C++ Wibor class."""

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

    def __init__(self, *args):
        r"""__init__(Wibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Wibor"""
        _QuantLib.Wibor_swiginit(self, _QuantLib.new_Wibor(*args))
    __swig_destroy__ = _QuantLib.delete_Wibor

# Register Wibor in _QuantLib:
_QuantLib.Wibor_swigregister(Wibor)
class Zibor(IborIndex):
    r"""Proxy of C++ Zibor class."""

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

    def __init__(self, *args):
        r"""__init__(Zibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Zibor"""
        _QuantLib.Zibor_swiginit(self, _QuantLib.new_Zibor(*args))
    __swig_destroy__ = _QuantLib.delete_Zibor

# Register Zibor in _QuantLib:
_QuantLib.Zibor_swigregister(Zibor)
class Aonia(OvernightIndex):
    r"""Proxy of C++ Aonia class."""

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

    def __init__(self, *args):
        r"""__init__(Aonia self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Aonia"""
        _QuantLib.Aonia_swiginit(self, _QuantLib.new_Aonia(*args))
    __swig_destroy__ = _QuantLib.delete_Aonia

# Register Aonia in _QuantLib:
_QuantLib.Aonia_swigregister(Aonia)
class Eonia(OvernightIndex):
    r"""Proxy of C++ Eonia class."""

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

    def __init__(self, *args):
        r"""__init__(Eonia self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Eonia"""
        _QuantLib.Eonia_swiginit(self, _QuantLib.new_Eonia(*args))
    __swig_destroy__ = _QuantLib.delete_Eonia

# Register Eonia in _QuantLib:
_QuantLib.Eonia_swigregister(Eonia)
class Sonia(OvernightIndex):
    r"""Proxy of C++ Sonia class."""

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

    def __init__(self, *args):
        r"""__init__(Sonia self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Sonia"""
        _QuantLib.Sonia_swiginit(self, _QuantLib.new_Sonia(*args))
    __swig_destroy__ = _QuantLib.delete_Sonia

# Register Sonia in _QuantLib:
_QuantLib.Sonia_swigregister(Sonia)
class FedFunds(OvernightIndex):
    r"""Proxy of C++ FedFunds class."""

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

    def __init__(self, *args):
        r"""__init__(FedFunds self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> FedFunds"""
        _QuantLib.FedFunds_swiginit(self, _QuantLib.new_FedFunds(*args))
    __swig_destroy__ = _QuantLib.delete_FedFunds

# Register FedFunds in _QuantLib:
_QuantLib.FedFunds_swigregister(FedFunds)
class Nzocr(OvernightIndex):
    r"""Proxy of C++ Nzocr class."""

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

    def __init__(self, *args):
        r"""__init__(Nzocr self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Nzocr"""
        _QuantLib.Nzocr_swiginit(self, _QuantLib.new_Nzocr(*args))
    __swig_destroy__ = _QuantLib.delete_Nzocr

# Register Nzocr in _QuantLib:
_QuantLib.Nzocr_swigregister(Nzocr)
class Sofr(OvernightIndex):
    r"""Proxy of C++ Sofr class."""

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

    def __init__(self, *args):
        r"""__init__(Sofr self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Sofr"""
        _QuantLib.Sofr_swiginit(self, _QuantLib.new_Sofr(*args))
    __swig_destroy__ = _QuantLib.delete_Sofr

# Register Sofr in _QuantLib:
_QuantLib.Sofr_swigregister(Sofr)
class Estr(OvernightIndex):
    r"""Proxy of C++ Estr class."""

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

    def __init__(self, *args):
        r"""__init__(Estr self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Estr"""
        _QuantLib.Estr_swiginit(self, _QuantLib.new_Estr(*args))
    __swig_destroy__ = _QuantLib.delete_Estr

# Register Estr in _QuantLib:
_QuantLib.Estr_swigregister(Estr)
class EuriborSwapIsdaFixA(SwapIndex):
    r"""Proxy of C++ EuriborSwapIsdaFixA class."""

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

    def __init__(self, *args):
        r"""
        __init__(EuriborSwapIsdaFixA self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EuriborSwapIsdaFixA
        __init__(EuriborSwapIsdaFixA self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EuriborSwapIsdaFixA
        """
        _QuantLib.EuriborSwapIsdaFixA_swiginit(self, _QuantLib.new_EuriborSwapIsdaFixA(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixA

# Register EuriborSwapIsdaFixA in _QuantLib:
_QuantLib.EuriborSwapIsdaFixA_swigregister(EuriborSwapIsdaFixA)
class EuriborSwapIsdaFixB(SwapIndex):
    r"""Proxy of C++ EuriborSwapIsdaFixB class."""

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

    def __init__(self, *args):
        r"""
        __init__(EuriborSwapIsdaFixB self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EuriborSwapIsdaFixB
        __init__(EuriborSwapIsdaFixB self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EuriborSwapIsdaFixB
        """
        _QuantLib.EuriborSwapIsdaFixB_swiginit(self, _QuantLib.new_EuriborSwapIsdaFixB(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixB

# Register EuriborSwapIsdaFixB in _QuantLib:
_QuantLib.EuriborSwapIsdaFixB_swigregister(EuriborSwapIsdaFixB)
class EuriborSwapIfrFix(SwapIndex):
    r"""Proxy of C++ EuriborSwapIfrFix class."""

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

    def __init__(self, *args):
        r"""
        __init__(EuriborSwapIfrFix self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EuriborSwapIfrFix
        __init__(EuriborSwapIfrFix self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EuriborSwapIfrFix
        """
        _QuantLib.EuriborSwapIfrFix_swiginit(self, _QuantLib.new_EuriborSwapIfrFix(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIfrFix

# Register EuriborSwapIfrFix in _QuantLib:
_QuantLib.EuriborSwapIfrFix_swigregister(EuriborSwapIfrFix)
class EurLiborSwapIsdaFixA(SwapIndex):
    r"""Proxy of C++ EurLiborSwapIsdaFixA class."""

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

    def __init__(self, *args):
        r"""
        __init__(EurLiborSwapIsdaFixA self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EurLiborSwapIsdaFixA
        __init__(EurLiborSwapIsdaFixA self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EurLiborSwapIsdaFixA
        """
        _QuantLib.EurLiborSwapIsdaFixA_swiginit(self, _QuantLib.new_EurLiborSwapIsdaFixA(*args))
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixA

# Register EurLiborSwapIsdaFixA in _QuantLib:
_QuantLib.EurLiborSwapIsdaFixA_swigregister(EurLiborSwapIsdaFixA)
class EurLiborSwapIsdaFixB(SwapIndex):
    r"""Proxy of C++ EurLiborSwapIsdaFixB class."""

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

    def __init__(self, *args):
        r"""
        __init__(EurLiborSwapIsdaFixB self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EurLiborSwapIsdaFixB
        __init__(EurLiborSwapIsdaFixB self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EurLiborSwapIsdaFixB
        """
        _QuantLib.EurLiborSwapIsdaFixB_swiginit(self, _QuantLib.new_EurLiborSwapIsdaFixB(*args))
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixB

# Register EurLiborSwapIsdaFixB in _QuantLib:
_QuantLib.EurLiborSwapIsdaFixB_swigregister(EurLiborSwapIsdaFixB)
class EurLiborSwapIfrFix(SwapIndex):
    r"""Proxy of C++ EurLiborSwapIfrFix class."""

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

    def __init__(self, *args):
        r"""
        __init__(EurLiborSwapIfrFix self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> EurLiborSwapIfrFix
        __init__(EurLiborSwapIfrFix self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EurLiborSwapIfrFix
        """
        _QuantLib.EurLiborSwapIfrFix_swiginit(self, _QuantLib.new_EurLiborSwapIfrFix(*args))
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIfrFix

# Register EurLiborSwapIfrFix in _QuantLib:
_QuantLib.EurLiborSwapIfrFix_swigregister(EurLiborSwapIfrFix)
class ChfLiborSwapIsdaFix(SwapIndex):
    r"""Proxy of C++ ChfLiborSwapIsdaFix class."""

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

    def __init__(self, *args):
        r"""
        __init__(ChfLiborSwapIsdaFix self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> ChfLiborSwapIsdaFix
        __init__(ChfLiborSwapIsdaFix self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> ChfLiborSwapIsdaFix
        """
        _QuantLib.ChfLiborSwapIsdaFix_swiginit(self, _QuantLib.new_ChfLiborSwapIsdaFix(*args))
    __swig_destroy__ = _QuantLib.delete_ChfLiborSwapIsdaFix

# Register ChfLiborSwapIsdaFix in _QuantLib:
_QuantLib.ChfLiborSwapIsdaFix_swigregister(ChfLiborSwapIsdaFix)
class GbpLiborSwapIsdaFix(SwapIndex):
    r"""Proxy of C++ GbpLiborSwapIsdaFix class."""

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

    def __init__(self, *args):
        r"""
        __init__(GbpLiborSwapIsdaFix self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> GbpLiborSwapIsdaFix
        __init__(GbpLiborSwapIsdaFix self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> GbpLiborSwapIsdaFix
        """
        _QuantLib.GbpLiborSwapIsdaFix_swiginit(self, _QuantLib.new_GbpLiborSwapIsdaFix(*args))
    __swig_destroy__ = _QuantLib.delete_GbpLiborSwapIsdaFix

# Register GbpLiborSwapIsdaFix in _QuantLib:
_QuantLib.GbpLiborSwapIsdaFix_swigregister(GbpLiborSwapIsdaFix)
class JpyLiborSwapIsdaFixAm(SwapIndex):
    r"""Proxy of C++ JpyLiborSwapIsdaFixAm class."""

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

    def __init__(self, *args):
        r"""
        __init__(JpyLiborSwapIsdaFixAm self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> JpyLiborSwapIsdaFixAm
        __init__(JpyLiborSwapIsdaFixAm self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> JpyLiborSwapIsdaFixAm
        """
        _QuantLib.JpyLiborSwapIsdaFixAm_swiginit(self, _QuantLib.new_JpyLiborSwapIsdaFixAm(*args))
    __swig_destroy__ = _QuantLib.delete_JpyLiborSwapIsdaFixAm

# Register JpyLiborSwapIsdaFixAm in _QuantLib:
_QuantLib.JpyLiborSwapIsdaFixAm_swigregister(JpyLiborSwapIsdaFixAm)
class JpyLiborSwapIsdaFixPm(SwapIndex):
    r"""Proxy of C++ JpyLiborSwapIsdaFixPm class."""

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

    def __init__(self, *args):
        r"""
        __init__(JpyLiborSwapIsdaFixPm self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> JpyLiborSwapIsdaFixPm
        __init__(JpyLiborSwapIsdaFixPm self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> JpyLiborSwapIsdaFixPm
        """
        _QuantLib.JpyLiborSwapIsdaFixPm_swiginit(self, _QuantLib.new_JpyLiborSwapIsdaFixPm(*args))
    __swig_destroy__ = _QuantLib.delete_JpyLiborSwapIsdaFixPm

# Register JpyLiborSwapIsdaFixPm in _QuantLib:
_QuantLib.JpyLiborSwapIsdaFixPm_swigregister(JpyLiborSwapIsdaFixPm)
class UsdLiborSwapIsdaFixAm(SwapIndex):
    r"""Proxy of C++ UsdLiborSwapIsdaFixAm class."""

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

    def __init__(self, *args):
        r"""
        __init__(UsdLiborSwapIsdaFixAm self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> UsdLiborSwapIsdaFixAm
        __init__(UsdLiborSwapIsdaFixAm self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> UsdLiborSwapIsdaFixAm
        """
        _QuantLib.UsdLiborSwapIsdaFixAm_swiginit(self, _QuantLib.new_UsdLiborSwapIsdaFixAm(*args))
    __swig_destroy__ = _QuantLib.delete_UsdLiborSwapIsdaFixAm

# Register UsdLiborSwapIsdaFixAm in _QuantLib:
_QuantLib.UsdLiborSwapIsdaFixAm_swigregister(UsdLiborSwapIsdaFixAm)
class UsdLiborSwapIsdaFixPm(SwapIndex):
    r"""Proxy of C++ UsdLiborSwapIsdaFixPm class."""

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

    def __init__(self, *args):
        r"""
        __init__(UsdLiborSwapIsdaFixPm self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> UsdLiborSwapIsdaFixPm
        __init__(UsdLiborSwapIsdaFixPm self, Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> UsdLiborSwapIsdaFixPm
        """
        _QuantLib.UsdLiborSwapIsdaFixPm_swiginit(self, _QuantLib.new_UsdLiborSwapIsdaFixPm(*args))
    __swig_destroy__ = _QuantLib.delete_UsdLiborSwapIsdaFixPm

# Register UsdLiborSwapIsdaFixPm in _QuantLib:
_QuantLib.UsdLiborSwapIsdaFixPm_swigregister(UsdLiborSwapIsdaFixPm)
class Bibor(IborIndex):
    r"""Proxy of C++ Bibor class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor self, Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor"""
        _QuantLib.Bibor_swiginit(self, _QuantLib.new_Bibor(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor

# Register Bibor in _QuantLib:
_QuantLib.Bibor_swigregister(Bibor)
class BiborSW(Bibor):
    r"""Proxy of C++ BiborSW class."""

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

    def __init__(self, *args):
        r"""__init__(BiborSW self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> BiborSW"""
        _QuantLib.BiborSW_swiginit(self, _QuantLib.new_BiborSW(*args))
    __swig_destroy__ = _QuantLib.delete_BiborSW

# Register BiborSW in _QuantLib:
_QuantLib.BiborSW_swigregister(BiborSW)
class Bibor1M(Bibor):
    r"""Proxy of C++ Bibor1M class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor1M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor1M"""
        _QuantLib.Bibor1M_swiginit(self, _QuantLib.new_Bibor1M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor1M

# Register Bibor1M in _QuantLib:
_QuantLib.Bibor1M_swigregister(Bibor1M)
class Bibor2M(Bibor):
    r"""Proxy of C++ Bibor2M class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor2M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor2M"""
        _QuantLib.Bibor2M_swiginit(self, _QuantLib.new_Bibor2M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor2M

# Register Bibor2M in _QuantLib:
_QuantLib.Bibor2M_swigregister(Bibor2M)
class Bibor3M(Bibor):
    r"""Proxy of C++ Bibor3M class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor3M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor3M"""
        _QuantLib.Bibor3M_swiginit(self, _QuantLib.new_Bibor3M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor3M

# Register Bibor3M in _QuantLib:
_QuantLib.Bibor3M_swigregister(Bibor3M)
class Bibor6M(Bibor):
    r"""Proxy of C++ Bibor6M class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor6M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor6M"""
        _QuantLib.Bibor6M_swiginit(self, _QuantLib.new_Bibor6M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor6M

# Register Bibor6M in _QuantLib:
_QuantLib.Bibor6M_swigregister(Bibor6M)
class Bibor9M(Bibor):
    r"""Proxy of C++ Bibor9M class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor9M self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor9M"""
        _QuantLib.Bibor9M_swiginit(self, _QuantLib.new_Bibor9M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor9M

# Register Bibor9M in _QuantLib:
_QuantLib.Bibor9M_swigregister(Bibor9M)
class Bibor1Y(Bibor):
    r"""Proxy of C++ Bibor1Y class."""

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

    def __init__(self, *args):
        r"""__init__(Bibor1Y self, YieldTermStructureHandle h=Handle< YieldTermStructure >()) -> Bibor1Y"""
        _QuantLib.Bibor1Y_swiginit(self, _QuantLib.new_Bibor1Y(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor1Y

# Register Bibor1Y in _QuantLib:
_QuantLib.Bibor1Y_swigregister(Bibor1Y)
ShiftedLognormal = _QuantLib.ShiftedLognormal

Normal = _QuantLib.Normal

class VolatilityTermStructure(TermStructure):
    r"""Proxy of C++ VolatilityTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def minStrike(self):
        r"""minStrike(VolatilityTermStructure self) -> Real"""
        return _QuantLib.VolatilityTermStructure_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(VolatilityTermStructure self) -> Real"""
        return _QuantLib.VolatilityTermStructure_maxStrike(self)
    __swig_destroy__ = _QuantLib.delete_VolatilityTermStructure

# Register VolatilityTermStructure in _QuantLib:
_QuantLib.VolatilityTermStructure_swigregister(VolatilityTermStructure)
class BlackVolTermStructure(VolatilityTermStructure):
    r"""Proxy of C++ BlackVolTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def blackVol(self, *args):
        r"""
        blackVol(BlackVolTermStructure self, Date arg2, Real strike, bool extrapolate=False) -> Volatility
        blackVol(BlackVolTermStructure self, Time arg2, Real strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.BlackVolTermStructure_blackVol(self, *args)

    def blackVariance(self, *args):
        r"""
        blackVariance(BlackVolTermStructure self, Date arg2, Real strike, bool extrapolate=False) -> Real
        blackVariance(BlackVolTermStructure self, Time arg2, Real strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.BlackVolTermStructure_blackVariance(self, *args)

    def blackForwardVol(self, *args):
        r"""
        blackForwardVol(BlackVolTermStructure self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Volatility
        blackForwardVol(BlackVolTermStructure self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.BlackVolTermStructure_blackForwardVol(self, *args)

    def blackForwardVariance(self, *args):
        r"""
        blackForwardVariance(BlackVolTermStructure self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Real
        blackForwardVariance(BlackVolTermStructure self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.BlackVolTermStructure_blackForwardVariance(self, *args)
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructure

# Register BlackVolTermStructure in _QuantLib:
_QuantLib.BlackVolTermStructure_swigregister(BlackVolTermStructure)
class BlackVolTermStructureHandle(object):
    r"""Proxy of C++ Handle< BlackVolTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(BlackVolTermStructureHandle self, ext::shared_ptr< BlackVolTermStructure > const & arg2=ext::shared_ptr()) -> BlackVolTermStructureHandle"""
        _QuantLib.BlackVolTermStructureHandle_swiginit(self, _QuantLib.new_BlackVolTermStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(BlackVolTermStructureHandle self) -> ext::shared_ptr< BlackVolTermStructure >"""
        return _QuantLib.BlackVolTermStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(BlackVolTermStructureHandle self) -> ext::shared_ptr< BlackVolTermStructure >"""
        return _QuantLib.BlackVolTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(BlackVolTermStructureHandle self) -> bool"""
        return _QuantLib.BlackVolTermStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(BlackVolTermStructureHandle self) -> bool"""
        return _QuantLib.BlackVolTermStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(BlackVolTermStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.BlackVolTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructureHandle

    def blackVol(self, *args):
        r"""
        blackVol(BlackVolTermStructureHandle self, Date arg2, Real strike, bool extrapolate=False) -> Volatility
        blackVol(BlackVolTermStructureHandle self, Time arg2, Real strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.BlackVolTermStructureHandle_blackVol(self, *args)

    def blackVariance(self, *args):
        r"""
        blackVariance(BlackVolTermStructureHandle self, Date arg2, Real strike, bool extrapolate=False) -> Real
        blackVariance(BlackVolTermStructureHandle self, Time arg2, Real strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.BlackVolTermStructureHandle_blackVariance(self, *args)

    def blackForwardVol(self, *args):
        r"""
        blackForwardVol(BlackVolTermStructureHandle self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Volatility
        blackForwardVol(BlackVolTermStructureHandle self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.BlackVolTermStructureHandle_blackForwardVol(self, *args)

    def blackForwardVariance(self, *args):
        r"""
        blackForwardVariance(BlackVolTermStructureHandle self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Real
        blackForwardVariance(BlackVolTermStructureHandle self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.BlackVolTermStructureHandle_blackForwardVariance(self, *args)

    def minStrike(self):
        r"""minStrike(BlackVolTermStructureHandle self) -> Real"""
        return _QuantLib.BlackVolTermStructureHandle_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(BlackVolTermStructureHandle self) -> Real"""
        return _QuantLib.BlackVolTermStructureHandle_maxStrike(self)

    def dayCounter(self):
        r"""dayCounter(BlackVolTermStructureHandle self) -> DayCounter"""
        return _QuantLib.BlackVolTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(BlackVolTermStructureHandle self, Date date) -> Time"""
        return _QuantLib.BlackVolTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(BlackVolTermStructureHandle self) -> Calendar"""
        return _QuantLib.BlackVolTermStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(BlackVolTermStructureHandle self) -> Date"""
        return _QuantLib.BlackVolTermStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(BlackVolTermStructureHandle self) -> Date"""
        return _QuantLib.BlackVolTermStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(BlackVolTermStructureHandle self) -> Time"""
        return _QuantLib.BlackVolTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(BlackVolTermStructureHandle self)"""
        return _QuantLib.BlackVolTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(BlackVolTermStructureHandle self)"""
        return _QuantLib.BlackVolTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(BlackVolTermStructureHandle self) -> bool"""
        return _QuantLib.BlackVolTermStructureHandle_allowsExtrapolation(self)

# Register BlackVolTermStructureHandle in _QuantLib:
_QuantLib.BlackVolTermStructureHandle_swigregister(BlackVolTermStructureHandle)
class RelinkableBlackVolTermStructureHandle(BlackVolTermStructureHandle):
    r"""Proxy of C++ RelinkableHandle< BlackVolTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableBlackVolTermStructureHandle self, ext::shared_ptr< BlackVolTermStructure > const & arg2=ext::shared_ptr()) -> RelinkableBlackVolTermStructureHandle"""
        _QuantLib.RelinkableBlackVolTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableBlackVolTermStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableBlackVolTermStructureHandle self, ext::shared_ptr< BlackVolTermStructure > const & arg2)"""
        return _QuantLib.RelinkableBlackVolTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableBlackVolTermStructureHandle self)"""
        return _QuantLib.RelinkableBlackVolTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableBlackVolTermStructureHandle

# Register RelinkableBlackVolTermStructureHandle in _QuantLib:
_QuantLib.RelinkableBlackVolTermStructureHandle_swigregister(RelinkableBlackVolTermStructureHandle)
class LocalVolTermStructure(VolatilityTermStructure):
    r"""Proxy of C++ LocalVolTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def localVol(self, *args):
        r"""
        localVol(LocalVolTermStructure self, Date arg2, Real u, bool extrapolate=False) -> Volatility
        localVol(LocalVolTermStructure self, Time arg2, Real u, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.LocalVolTermStructure_localVol(self, *args)
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructure

# Register LocalVolTermStructure in _QuantLib:
_QuantLib.LocalVolTermStructure_swigregister(LocalVolTermStructure)
class LocalVolTermStructureHandle(object):
    r"""Proxy of C++ Handle< LocalVolTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(LocalVolTermStructureHandle self, ext::shared_ptr< LocalVolTermStructure > const & arg2=ext::shared_ptr()) -> LocalVolTermStructureHandle"""
        _QuantLib.LocalVolTermStructureHandle_swiginit(self, _QuantLib.new_LocalVolTermStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(LocalVolTermStructureHandle self) -> ext::shared_ptr< LocalVolTermStructure >"""
        return _QuantLib.LocalVolTermStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(LocalVolTermStructureHandle self) -> ext::shared_ptr< LocalVolTermStructure >"""
        return _QuantLib.LocalVolTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(LocalVolTermStructureHandle self) -> bool"""
        return _QuantLib.LocalVolTermStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(LocalVolTermStructureHandle self) -> bool"""
        return _QuantLib.LocalVolTermStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(LocalVolTermStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.LocalVolTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructureHandle

    def localVol(self, *args):
        r"""
        localVol(LocalVolTermStructureHandle self, Date arg2, Real u, bool extrapolate=False) -> Volatility
        localVol(LocalVolTermStructureHandle self, Time arg2, Real u, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.LocalVolTermStructureHandle_localVol(self, *args)

    def minStrike(self):
        r"""minStrike(LocalVolTermStructureHandle self) -> Real"""
        return _QuantLib.LocalVolTermStructureHandle_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(LocalVolTermStructureHandle self) -> Real"""
        return _QuantLib.LocalVolTermStructureHandle_maxStrike(self)

    def dayCounter(self):
        r"""dayCounter(LocalVolTermStructureHandle self) -> DayCounter"""
        return _QuantLib.LocalVolTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(LocalVolTermStructureHandle self, Date date) -> Time"""
        return _QuantLib.LocalVolTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(LocalVolTermStructureHandle self) -> Calendar"""
        return _QuantLib.LocalVolTermStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(LocalVolTermStructureHandle self) -> Date"""
        return _QuantLib.LocalVolTermStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(LocalVolTermStructureHandle self) -> Date"""
        return _QuantLib.LocalVolTermStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(LocalVolTermStructureHandle self) -> Time"""
        return _QuantLib.LocalVolTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(LocalVolTermStructureHandle self)"""
        return _QuantLib.LocalVolTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(LocalVolTermStructureHandle self)"""
        return _QuantLib.LocalVolTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(LocalVolTermStructureHandle self) -> bool"""
        return _QuantLib.LocalVolTermStructureHandle_allowsExtrapolation(self)

# Register LocalVolTermStructureHandle in _QuantLib:
_QuantLib.LocalVolTermStructureHandle_swigregister(LocalVolTermStructureHandle)
class RelinkableLocalVolTermStructureHandle(LocalVolTermStructureHandle):
    r"""Proxy of C++ RelinkableHandle< LocalVolTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableLocalVolTermStructureHandle self, ext::shared_ptr< LocalVolTermStructure > const & arg2=ext::shared_ptr()) -> RelinkableLocalVolTermStructureHandle"""
        _QuantLib.RelinkableLocalVolTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableLocalVolTermStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableLocalVolTermStructureHandle self, ext::shared_ptr< LocalVolTermStructure > const & arg2)"""
        return _QuantLib.RelinkableLocalVolTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableLocalVolTermStructureHandle self)"""
        return _QuantLib.RelinkableLocalVolTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableLocalVolTermStructureHandle

# Register RelinkableLocalVolTermStructureHandle in _QuantLib:
_QuantLib.RelinkableLocalVolTermStructureHandle_swigregister(RelinkableLocalVolTermStructureHandle)
class OptionletVolatilityStructure(VolatilityTermStructure):
    r"""Proxy of C++ OptionletVolatilityStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def volatility(self, *args):
        r"""
        volatility(OptionletVolatilityStructure self, Date arg2, Real strike, bool extrapolate=False) -> Volatility
        volatility(OptionletVolatilityStructure self, Time arg2, Real strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.OptionletVolatilityStructure_volatility(self, *args)

    def blackVariance(self, *args):
        r"""
        blackVariance(OptionletVolatilityStructure self, Date arg2, Rate strike, bool extrapolate=False) -> Real
        blackVariance(OptionletVolatilityStructure self, Time arg2, Rate strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.OptionletVolatilityStructure_blackVariance(self, *args)
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructure

# Register OptionletVolatilityStructure in _QuantLib:
_QuantLib.OptionletVolatilityStructure_swigregister(OptionletVolatilityStructure)
class OptionletVolatilityStructureHandle(object):
    r"""Proxy of C++ Handle< OptionletVolatilityStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(OptionletVolatilityStructureHandle self, ext::shared_ptr< OptionletVolatilityStructure > const & arg2=ext::shared_ptr()) -> OptionletVolatilityStructureHandle"""
        _QuantLib.OptionletVolatilityStructureHandle_swiginit(self, _QuantLib.new_OptionletVolatilityStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(OptionletVolatilityStructureHandle self) -> ext::shared_ptr< OptionletVolatilityStructure >"""
        return _QuantLib.OptionletVolatilityStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(OptionletVolatilityStructureHandle self) -> ext::shared_ptr< OptionletVolatilityStructure >"""
        return _QuantLib.OptionletVolatilityStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(OptionletVolatilityStructureHandle self) -> bool"""
        return _QuantLib.OptionletVolatilityStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(OptionletVolatilityStructureHandle self) -> bool"""
        return _QuantLib.OptionletVolatilityStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(OptionletVolatilityStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.OptionletVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructureHandle

    def volatility(self, *args):
        r"""
        volatility(OptionletVolatilityStructureHandle self, Date arg2, Real strike, bool extrapolate=False) -> Volatility
        volatility(OptionletVolatilityStructureHandle self, Time arg2, Real strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.OptionletVolatilityStructureHandle_volatility(self, *args)

    def blackVariance(self, *args):
        r"""
        blackVariance(OptionletVolatilityStructureHandle self, Date arg2, Rate strike, bool extrapolate=False) -> Real
        blackVariance(OptionletVolatilityStructureHandle self, Time arg2, Rate strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.OptionletVolatilityStructureHandle_blackVariance(self, *args)

    def minStrike(self):
        r"""minStrike(OptionletVolatilityStructureHandle self) -> Real"""
        return _QuantLib.OptionletVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(OptionletVolatilityStructureHandle self) -> Real"""
        return _QuantLib.OptionletVolatilityStructureHandle_maxStrike(self)

    def dayCounter(self):
        r"""dayCounter(OptionletVolatilityStructureHandle self) -> DayCounter"""
        return _QuantLib.OptionletVolatilityStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(OptionletVolatilityStructureHandle self, Date date) -> Time"""
        return _QuantLib.OptionletVolatilityStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(OptionletVolatilityStructureHandle self) -> Calendar"""
        return _QuantLib.OptionletVolatilityStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(OptionletVolatilityStructureHandle self) -> Date"""
        return _QuantLib.OptionletVolatilityStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(OptionletVolatilityStructureHandle self) -> Date"""
        return _QuantLib.OptionletVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(OptionletVolatilityStructureHandle self) -> Time"""
        return _QuantLib.OptionletVolatilityStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(OptionletVolatilityStructureHandle self)"""
        return _QuantLib.OptionletVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(OptionletVolatilityStructureHandle self)"""
        return _QuantLib.OptionletVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(OptionletVolatilityStructureHandle self) -> bool"""
        return _QuantLib.OptionletVolatilityStructureHandle_allowsExtrapolation(self)

# Register OptionletVolatilityStructureHandle in _QuantLib:
_QuantLib.OptionletVolatilityStructureHandle_swigregister(OptionletVolatilityStructureHandle)
class RelinkableOptionletVolatilityStructureHandle(OptionletVolatilityStructureHandle):
    r"""Proxy of C++ RelinkableHandle< OptionletVolatilityStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableOptionletVolatilityStructureHandle self, ext::shared_ptr< OptionletVolatilityStructure > const & arg2=ext::shared_ptr()) -> RelinkableOptionletVolatilityStructureHandle"""
        _QuantLib.RelinkableOptionletVolatilityStructureHandle_swiginit(self, _QuantLib.new_RelinkableOptionletVolatilityStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableOptionletVolatilityStructureHandle self, ext::shared_ptr< OptionletVolatilityStructure > const & arg2)"""
        return _QuantLib.RelinkableOptionletVolatilityStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableOptionletVolatilityStructureHandle self)"""
        return _QuantLib.RelinkableOptionletVolatilityStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableOptionletVolatilityStructureHandle

# Register RelinkableOptionletVolatilityStructureHandle in _QuantLib:
_QuantLib.RelinkableOptionletVolatilityStructureHandle_swigregister(RelinkableOptionletVolatilityStructureHandle)
class YoYOptionletVolatilitySurface(VolatilityTermStructure):
    r"""Proxy of C++ YoYOptionletVolatilitySurface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def observationLag(self):
        r"""observationLag(YoYOptionletVolatilitySurface self) -> Period"""
        return _QuantLib.YoYOptionletVolatilitySurface_observationLag(self)

    def frequency(self):
        r"""frequency(YoYOptionletVolatilitySurface self) -> Real"""
        return _QuantLib.YoYOptionletVolatilitySurface_frequency(self)

    def indexIsInterpolated(self):
        r"""indexIsInterpolated(YoYOptionletVolatilitySurface self) -> bool"""
        return _QuantLib.YoYOptionletVolatilitySurface_indexIsInterpolated(self)

    def baseDate(self):
        r"""baseDate(YoYOptionletVolatilitySurface self) -> Date"""
        return _QuantLib.YoYOptionletVolatilitySurface_baseDate(self)

    def timeFromBase(self, *args):
        r"""timeFromBase(YoYOptionletVolatilitySurface self, Date date, Period obsLag=Period(-1,Days)) -> Time"""
        return _QuantLib.YoYOptionletVolatilitySurface_timeFromBase(self, *args)

    def minStrike(self):
        r"""minStrike(YoYOptionletVolatilitySurface self) -> Real"""
        return _QuantLib.YoYOptionletVolatilitySurface_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(YoYOptionletVolatilitySurface self) -> Real"""
        return _QuantLib.YoYOptionletVolatilitySurface_maxStrike(self)

    def baseLevel(self):
        r"""baseLevel(YoYOptionletVolatilitySurface self) -> Volatility"""
        return _QuantLib.YoYOptionletVolatilitySurface_baseLevel(self)

    def volatility(self, *args):
        r"""
        volatility(YoYOptionletVolatilitySurface self, Date maturityDate, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility
        volatility(YoYOptionletVolatilitySurface self, Period optionTenor, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility
        """
        return _QuantLib.YoYOptionletVolatilitySurface_volatility(self, *args)

    def totalVariance(self, *args):
        r"""
        totalVariance(YoYOptionletVolatilitySurface self, Date exerciseDate, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real
        totalVariance(YoYOptionletVolatilitySurface self, Period optionTenor, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real
        """
        return _QuantLib.YoYOptionletVolatilitySurface_totalVariance(self, *args)
    __swig_destroy__ = _QuantLib.delete_YoYOptionletVolatilitySurface

# Register YoYOptionletVolatilitySurface in _QuantLib:
_QuantLib.YoYOptionletVolatilitySurface_swigregister(YoYOptionletVolatilitySurface)
class YoYOptionletVolatilitySurfaceHandle(object):
    r"""Proxy of C++ Handle< YoYOptionletVolatilitySurface > class."""

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

    def __init__(self, *args):
        r"""__init__(YoYOptionletVolatilitySurfaceHandle self, ext::shared_ptr< YoYOptionletVolatilitySurface > const & arg2=ext::shared_ptr()) -> YoYOptionletVolatilitySurfaceHandle"""
        _QuantLib.YoYOptionletVolatilitySurfaceHandle_swiginit(self, _QuantLib.new_YoYOptionletVolatilitySurfaceHandle(*args))

    def __deref__(self):
        r"""__deref__(YoYOptionletVolatilitySurfaceHandle self) -> ext::shared_ptr< YoYOptionletVolatilitySurface >"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(YoYOptionletVolatilitySurfaceHandle self) -> ext::shared_ptr< YoYOptionletVolatilitySurface >"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(YoYOptionletVolatilitySurfaceHandle self) -> bool"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(YoYOptionletVolatilitySurfaceHandle self) -> bool"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(YoYOptionletVolatilitySurfaceHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YoYOptionletVolatilitySurfaceHandle

    def observationLag(self):
        r"""observationLag(YoYOptionletVolatilitySurfaceHandle self) -> Period"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_observationLag(self)

    def frequency(self):
        r"""frequency(YoYOptionletVolatilitySurfaceHandle self) -> Real"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_frequency(self)

    def indexIsInterpolated(self):
        r"""indexIsInterpolated(YoYOptionletVolatilitySurfaceHandle self) -> bool"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated(self)

    def baseDate(self):
        r"""baseDate(YoYOptionletVolatilitySurfaceHandle self) -> Date"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_baseDate(self)

    def timeFromBase(self, *args):
        r"""timeFromBase(YoYOptionletVolatilitySurfaceHandle self, Date date, Period obsLag=Period(-1,Days)) -> Time"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_timeFromBase(self, *args)

    def minStrike(self):
        r"""minStrike(YoYOptionletVolatilitySurfaceHandle self) -> Real"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(YoYOptionletVolatilitySurfaceHandle self) -> Real"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_maxStrike(self)

    def baseLevel(self):
        r"""baseLevel(YoYOptionletVolatilitySurfaceHandle self) -> Volatility"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_baseLevel(self)

    def volatility(self, *args):
        r"""
        volatility(YoYOptionletVolatilitySurfaceHandle self, Date maturityDate, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility
        volatility(YoYOptionletVolatilitySurfaceHandle self, Period optionTenor, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility
        """
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_volatility(self, *args)

    def totalVariance(self, *args):
        r"""
        totalVariance(YoYOptionletVolatilitySurfaceHandle self, Date exerciseDate, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real
        totalVariance(YoYOptionletVolatilitySurfaceHandle self, Period optionTenor, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real
        """
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_totalVariance(self, *args)

    def dayCounter(self):
        r"""dayCounter(YoYOptionletVolatilitySurfaceHandle self) -> DayCounter"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(YoYOptionletVolatilitySurfaceHandle self, Date date) -> Time"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(YoYOptionletVolatilitySurfaceHandle self) -> Calendar"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(YoYOptionletVolatilitySurfaceHandle self) -> Date"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(YoYOptionletVolatilitySurfaceHandle self) -> Date"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(YoYOptionletVolatilitySurfaceHandle self) -> Time"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(YoYOptionletVolatilitySurfaceHandle self)"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(YoYOptionletVolatilitySurfaceHandle self)"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(YoYOptionletVolatilitySurfaceHandle self) -> bool"""
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation(self)

# Register YoYOptionletVolatilitySurfaceHandle in _QuantLib:
_QuantLib.YoYOptionletVolatilitySurfaceHandle_swigregister(YoYOptionletVolatilitySurfaceHandle)
class RelinkableYoYOptionletVolatilitySurfaceHandle(YoYOptionletVolatilitySurfaceHandle):
    r"""Proxy of C++ RelinkableHandle< YoYOptionletVolatilitySurface > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableYoYOptionletVolatilitySurfaceHandle self, ext::shared_ptr< YoYOptionletVolatilitySurface > const & arg2=ext::shared_ptr()) -> RelinkableYoYOptionletVolatilitySurfaceHandle"""
        _QuantLib.RelinkableYoYOptionletVolatilitySurfaceHandle_swiginit(self, _QuantLib.new_RelinkableYoYOptionletVolatilitySurfaceHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableYoYOptionletVolatilitySurfaceHandle self, ext::shared_ptr< YoYOptionletVolatilitySurface > const & arg2)"""
        return _QuantLib.RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableYoYOptionletVolatilitySurfaceHandle self)"""
        return _QuantLib.RelinkableYoYOptionletVolatilitySurfaceHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableYoYOptionletVolatilitySurfaceHandle

# Register RelinkableYoYOptionletVolatilitySurfaceHandle in _QuantLib:
_QuantLib.RelinkableYoYOptionletVolatilitySurfaceHandle_swigregister(RelinkableYoYOptionletVolatilitySurfaceHandle)

def RelinkableYoYOptionletVolatilitySurface(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (RelinkableYoYOptionletVolatilitySurface.__name__, RelinkableYoYOptionletVolatilitySurfaceHandle.__name__))
    return RelinkableYoYOptionletVolatilitySurfaceHandle(*args, **kwargs)

class SmileSection(Observable):
    r"""Proxy of C++ SmileSection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def minStrike(self):
        r"""minStrike(SmileSection self) -> Real"""
        return _QuantLib.SmileSection_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(SmileSection self) -> Real"""
        return _QuantLib.SmileSection_maxStrike(self)

    def atmLevel(self):
        r"""atmLevel(SmileSection self) -> Real"""
        return _QuantLib.SmileSection_atmLevel(self)

    def variance(self, strike):
        r"""variance(SmileSection self, Rate strike) -> Real"""
        return _QuantLib.SmileSection_variance(self, strike)

    def exerciseDate(self):
        r"""exerciseDate(SmileSection self) -> Date"""
        return _QuantLib.SmileSection_exerciseDate(self)

    def volatilityType(self):
        r"""volatilityType(SmileSection self) -> VolatilityType"""
        return _QuantLib.SmileSection_volatilityType(self)

    def shift(self):
        r"""shift(SmileSection self) -> Rate"""
        return _QuantLib.SmileSection_shift(self)

    def referenceDate(self):
        r"""referenceDate(SmileSection self) -> Date"""
        return _QuantLib.SmileSection_referenceDate(self)

    def exerciseTime(self):
        r"""exerciseTime(SmileSection self) -> Time"""
        return _QuantLib.SmileSection_exerciseTime(self)

    def dayCounter(self):
        r"""dayCounter(SmileSection self) -> DayCounter"""
        return _QuantLib.SmileSection_dayCounter(self)

    def optionPrice(self, *args):
        r"""optionPrice(SmileSection self, Rate strike, Option::Type type=Call, Real discount=1.0) -> Real"""
        return _QuantLib.SmileSection_optionPrice(self, *args)

    def digitalOptionPrice(self, *args):
        r"""digitalOptionPrice(SmileSection self, Rate strike, Option::Type type=Call, Real discount=1.0, Real gap=1.0e-5) -> Real"""
        return _QuantLib.SmileSection_digitalOptionPrice(self, *args)

    def vega(self, strike, discount=1.0):
        r"""vega(SmileSection self, Rate strike, Real discount=1.0) -> Real"""
        return _QuantLib.SmileSection_vega(self, strike, discount)

    def density(self, strike, discount=1.0, gap=1.0E-4):
        r"""density(SmileSection self, Rate strike, Real discount=1.0, Real gap=1.0E-4) -> Real"""
        return _QuantLib.SmileSection_density(self, strike, discount, gap)

    def volatility(self, *args):
        r"""
        volatility(SmileSection self, Rate strike) -> Volatility
        volatility(SmileSection self, Rate strike, VolatilityType type, Real shift=0.0) -> Volatility
        """
        return _QuantLib.SmileSection_volatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_SmileSection

# Register SmileSection in _QuantLib:
_QuantLib.SmileSection_swigregister(SmileSection)
class SmileSectionVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< SmileSection > > class."""

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

    def iterator(self):
        r"""iterator(SmileSectionVector self) -> SwigPyIterator"""
        return _QuantLib.SmileSectionVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(SmileSectionVector self) -> bool"""
        return _QuantLib.SmileSectionVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(SmileSectionVector self) -> bool"""
        return _QuantLib.SmileSectionVector___bool__(self)

    def __len__(self):
        r"""__len__(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::size_type"""
        return _QuantLib.SmileSectionVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j) -> SmileSectionVector"""
        return _QuantLib.SmileSectionVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j)
        __setslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j, SmileSectionVector v)
        """
        return _QuantLib.SmileSectionVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j)"""
        return _QuantLib.SmileSectionVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i)
        __delitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.SmileSectionVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice) -> SmileSectionVector
        __getitem__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i) -> std::vector< ext::shared_ptr< SmileSection > >::value_type const &
        """
        return _QuantLib.SmileSectionVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice, SmileSectionVector v)
        __setitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)
        """
        return _QuantLib.SmileSectionVector___setitem__(self, *args)

    def pop(self):
        r"""pop(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::value_type"""
        return _QuantLib.SmileSectionVector_pop(self)

    def append(self, x):
        r"""append(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)"""
        return _QuantLib.SmileSectionVector_append(self, x)

    def empty(self):
        r"""empty(SmileSectionVector self) -> bool"""
        return _QuantLib.SmileSectionVector_empty(self)

    def size(self):
        r"""size(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::size_type"""
        return _QuantLib.SmileSectionVector_size(self)

    def swap(self, v):
        r"""swap(SmileSectionVector self, SmileSectionVector v)"""
        return _QuantLib.SmileSectionVector_swap(self, v)

    def begin(self):
        r"""begin(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::iterator"""
        return _QuantLib.SmileSectionVector_begin(self)

    def end(self):
        r"""end(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::iterator"""
        return _QuantLib.SmileSectionVector_end(self)

    def rbegin(self):
        r"""rbegin(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator"""
        return _QuantLib.SmileSectionVector_rbegin(self)

    def rend(self):
        r"""rend(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator"""
        return _QuantLib.SmileSectionVector_rend(self)

    def clear(self):
        r"""clear(SmileSectionVector self)"""
        return _QuantLib.SmileSectionVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::allocator_type"""
        return _QuantLib.SmileSectionVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(SmileSectionVector self)"""
        return _QuantLib.SmileSectionVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator pos) -> std::vector< ext::shared_ptr< SmileSection > >::iterator
        erase(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator first, std::vector< ext::shared_ptr< SmileSection > >::iterator last) -> std::vector< ext::shared_ptr< SmileSection > >::iterator
        """
        return _QuantLib.SmileSectionVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(SmileSectionVector self) -> SmileSectionVector
        __init__(SmileSectionVector self, SmileSectionVector other) -> SmileSectionVector
        __init__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type size) -> SmileSectionVector
        __init__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type size, std::vector< ext::shared_ptr< SmileSection > >::value_type const & value) -> SmileSectionVector
        """
        _QuantLib.SmileSectionVector_swiginit(self, _QuantLib.new_SmileSectionVector(*args))

    def push_back(self, x):
        r"""push_back(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)"""
        return _QuantLib.SmileSectionVector_push_back(self, x)

    def front(self):
        r"""front(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::value_type const &"""
        return _QuantLib.SmileSectionVector_front(self)

    def back(self):
        r"""back(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::value_type const &"""
        return _QuantLib.SmileSectionVector_back(self)

    def assign(self, n, x):
        r"""assign(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type n, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)"""
        return _QuantLib.SmileSectionVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type new_size)
        resize(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type new_size, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)
        """
        return _QuantLib.SmileSectionVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator pos, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x) -> std::vector< ext::shared_ptr< SmileSection > >::iterator
        insert(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator pos, std::vector< ext::shared_ptr< SmileSection > >::size_type n, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)
        """
        return _QuantLib.SmileSectionVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type n)"""
        return _QuantLib.SmileSectionVector_reserve(self, n)

    def capacity(self):
        r"""capacity(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::size_type"""
        return _QuantLib.SmileSectionVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_SmileSectionVector

# Register SmileSectionVector in _QuantLib:
_QuantLib.SmileSectionVector_swigregister(SmileSectionVector)
class SwaptionVolatilityStructure(VolatilityTermStructure):
    r"""Proxy of C++ SwaptionVolatilityStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def volatility(self, *args):
        r"""
        volatility(SwaptionVolatilityStructure self, Date start, Period length, Rate strike, bool extrapolate=False) -> Volatility
        volatility(SwaptionVolatilityStructure self, Time start, Time length, Rate strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.SwaptionVolatilityStructure_volatility(self, *args)

    def blackVariance(self, *args):
        r"""
        blackVariance(SwaptionVolatilityStructure self, Date start, Period length, Rate strike, bool extrapolate=False) -> Real
        blackVariance(SwaptionVolatilityStructure self, Time start, Time length, Rate strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.SwaptionVolatilityStructure_blackVariance(self, *args)

    def optionDateFromTenor(self, p):
        r"""optionDateFromTenor(SwaptionVolatilityStructure self, Period p) -> Date"""
        return _QuantLib.SwaptionVolatilityStructure_optionDateFromTenor(self, p)

    def shift(self, *args):
        r"""
        shift(SwaptionVolatilityStructure self, Period optionTenor, Period swapTenor, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructure self, Date optionDate, Period swapTenor, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructure self, Time optionTime, Period swapTenor, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructure self, Period optionTenor, Time swapLength, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructure self, Date optionDate, Time swapLength, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructure self, Time optionTime, Time swapLength, bool extrapolate=False) -> Real
        """
        return _QuantLib.SwaptionVolatilityStructure_shift(self, *args)

    def smileSection(self, *args):
        r"""
        smileSection(SwaptionVolatilityStructure self, Period optionTenor, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructure self, Date optionDate, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructure self, Time optionTime, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructure self, Period optionTenor, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructure self, Date optionDate, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructure self, Time optionTime, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >
        """
        return _QuantLib.SwaptionVolatilityStructure_smileSection(self, *args)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructure

# Register SwaptionVolatilityStructure in _QuantLib:
_QuantLib.SwaptionVolatilityStructure_swigregister(SwaptionVolatilityStructure)
class SwaptionVolatilityStructureHandle(object):
    r"""Proxy of C++ Handle< SwaptionVolatilityStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(SwaptionVolatilityStructureHandle self, ext::shared_ptr< SwaptionVolatilityStructure > const & arg2=ext::shared_ptr()) -> SwaptionVolatilityStructureHandle"""
        _QuantLib.SwaptionVolatilityStructureHandle_swiginit(self, _QuantLib.new_SwaptionVolatilityStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(SwaptionVolatilityStructureHandle self) -> ext::shared_ptr< SwaptionVolatilityStructure >"""
        return _QuantLib.SwaptionVolatilityStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(SwaptionVolatilityStructureHandle self) -> ext::shared_ptr< SwaptionVolatilityStructure >"""
        return _QuantLib.SwaptionVolatilityStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(SwaptionVolatilityStructureHandle self) -> bool"""
        return _QuantLib.SwaptionVolatilityStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(SwaptionVolatilityStructureHandle self) -> bool"""
        return _QuantLib.SwaptionVolatilityStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(SwaptionVolatilityStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.SwaptionVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructureHandle

    def volatility(self, *args):
        r"""
        volatility(SwaptionVolatilityStructureHandle self, Date start, Period length, Rate strike, bool extrapolate=False) -> Volatility
        volatility(SwaptionVolatilityStructureHandle self, Time start, Time length, Rate strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.SwaptionVolatilityStructureHandle_volatility(self, *args)

    def blackVariance(self, *args):
        r"""
        blackVariance(SwaptionVolatilityStructureHandle self, Date start, Period length, Rate strike, bool extrapolate=False) -> Real
        blackVariance(SwaptionVolatilityStructureHandle self, Time start, Time length, Rate strike, bool extrapolate=False) -> Real
        """
        return _QuantLib.SwaptionVolatilityStructureHandle_blackVariance(self, *args)

    def optionDateFromTenor(self, p):
        r"""optionDateFromTenor(SwaptionVolatilityStructureHandle self, Period p) -> Date"""
        return _QuantLib.SwaptionVolatilityStructureHandle_optionDateFromTenor(self, p)

    def shift(self, *args):
        r"""
        shift(SwaptionVolatilityStructureHandle self, Period optionTenor, Period swapTenor, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructureHandle self, Date optionDate, Period swapTenor, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructureHandle self, Time optionTime, Period swapTenor, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructureHandle self, Period optionTenor, Time swapLength, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructureHandle self, Date optionDate, Time swapLength, bool extrapolate=False) -> Real
        shift(SwaptionVolatilityStructureHandle self, Time optionTime, Time swapLength, bool extrapolate=False) -> Real
        """
        return _QuantLib.SwaptionVolatilityStructureHandle_shift(self, *args)

    def smileSection(self, *args):
        r"""
        smileSection(SwaptionVolatilityStructureHandle self, Period optionTenor, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructureHandle self, Date optionDate, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructureHandle self, Time optionTime, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructureHandle self, Period optionTenor, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructureHandle self, Date optionDate, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >
        smileSection(SwaptionVolatilityStructureHandle self, Time optionTime, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >
        """
        return _QuantLib.SwaptionVolatilityStructureHandle_smileSection(self, *args)

    def minStrike(self):
        r"""minStrike(SwaptionVolatilityStructureHandle self) -> Real"""
        return _QuantLib.SwaptionVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(SwaptionVolatilityStructureHandle self) -> Real"""
        return _QuantLib.SwaptionVolatilityStructureHandle_maxStrike(self)

    def dayCounter(self):
        r"""dayCounter(SwaptionVolatilityStructureHandle self) -> DayCounter"""
        return _QuantLib.SwaptionVolatilityStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(SwaptionVolatilityStructureHandle self, Date date) -> Time"""
        return _QuantLib.SwaptionVolatilityStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(SwaptionVolatilityStructureHandle self) -> Calendar"""
        return _QuantLib.SwaptionVolatilityStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(SwaptionVolatilityStructureHandle self) -> Date"""
        return _QuantLib.SwaptionVolatilityStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(SwaptionVolatilityStructureHandle self) -> Date"""
        return _QuantLib.SwaptionVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(SwaptionVolatilityStructureHandle self) -> Time"""
        return _QuantLib.SwaptionVolatilityStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(SwaptionVolatilityStructureHandle self)"""
        return _QuantLib.SwaptionVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(SwaptionVolatilityStructureHandle self)"""
        return _QuantLib.SwaptionVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(SwaptionVolatilityStructureHandle self) -> bool"""
        return _QuantLib.SwaptionVolatilityStructureHandle_allowsExtrapolation(self)

# Register SwaptionVolatilityStructureHandle in _QuantLib:
_QuantLib.SwaptionVolatilityStructureHandle_swigregister(SwaptionVolatilityStructureHandle)
class RelinkableSwaptionVolatilityStructureHandle(SwaptionVolatilityStructureHandle):
    r"""Proxy of C++ RelinkableHandle< SwaptionVolatilityStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableSwaptionVolatilityStructureHandle self, ext::shared_ptr< SwaptionVolatilityStructure > const & arg2=ext::shared_ptr()) -> RelinkableSwaptionVolatilityStructureHandle"""
        _QuantLib.RelinkableSwaptionVolatilityStructureHandle_swiginit(self, _QuantLib.new_RelinkableSwaptionVolatilityStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableSwaptionVolatilityStructureHandle self, ext::shared_ptr< SwaptionVolatilityStructure > const & arg2)"""
        return _QuantLib.RelinkableSwaptionVolatilityStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableSwaptionVolatilityStructureHandle self)"""
        return _QuantLib.RelinkableSwaptionVolatilityStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableSwaptionVolatilityStructureHandle

# Register RelinkableSwaptionVolatilityStructureHandle in _QuantLib:
_QuantLib.RelinkableSwaptionVolatilityStructureHandle_swigregister(RelinkableSwaptionVolatilityStructureHandle)
class BlackConstantVol(BlackVolTermStructure):
    r"""Proxy of C++ BlackConstantVol class."""

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

    def __init__(self, *args):
        r"""
        __init__(BlackConstantVol self, Date referenceDate, Calendar c, Volatility volatility, DayCounter dayCounter) -> BlackConstantVol
        __init__(BlackConstantVol self, Date referenceDate, Calendar c, QuoteHandle volatility, DayCounter dayCounter) -> BlackConstantVol
        __init__(BlackConstantVol self, Natural settlementDays, Calendar calendar, Volatility volatility, DayCounter dayCounter) -> BlackConstantVol
        __init__(BlackConstantVol self, Natural settlementDays, Calendar calendar, QuoteHandle volatility, DayCounter dayCounter) -> BlackConstantVol
        """
        _QuantLib.BlackConstantVol_swiginit(self, _QuantLib.new_BlackConstantVol(*args))
    __swig_destroy__ = _QuantLib.delete_BlackConstantVol

# Register BlackConstantVol in _QuantLib:
_QuantLib.BlackConstantVol_swigregister(BlackConstantVol)
class BlackVarianceCurve(BlackVolTermStructure):
    r"""Proxy of C++ BlackVarianceCurve class."""

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

    def __init__(self, referenceDate, dates, volatilities, dayCounter, forceMonotoneVariance=True):
        r"""__init__(BlackVarianceCurve self, Date referenceDate, DateVector dates, DoubleVector volatilities, DayCounter dayCounter, bool forceMonotoneVariance=True) -> BlackVarianceCurve"""
        _QuantLib.BlackVarianceCurve_swiginit(self, _QuantLib.new_BlackVarianceCurve(referenceDate, dates, volatilities, dayCounter, forceMonotoneVariance))
    __swig_destroy__ = _QuantLib.delete_BlackVarianceCurve

# Register BlackVarianceCurve in _QuantLib:
_QuantLib.BlackVarianceCurve_swigregister(BlackVarianceCurve)
class BlackVarianceSurface(BlackVolTermStructure):
    r"""Proxy of C++ BlackVarianceSurface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ConstantExtrapolation = _QuantLib.BlackVarianceSurface_ConstantExtrapolation
    
    InterpolatorDefaultExtrapolation = _QuantLib.BlackVarianceSurface_InterpolatorDefaultExtrapolation
    

    def __init__(self, *args, **kwargs):
        r"""__init__(BlackVarianceSurface self, Date referenceDate, Calendar cal, DateVector dates, DoubleVector strikes, Matrix blackVols, DayCounter dayCounter, BlackVarianceSurface::Extrapolation lower=InterpolatorDefaultExtrapolation, BlackVarianceSurface::Extrapolation upper=InterpolatorDefaultExtrapolation, std::string const & interpolator="") -> BlackVarianceSurface"""
        _QuantLib.BlackVarianceSurface_swiginit(self, _QuantLib.new_BlackVarianceSurface(*args, **kwargs))

    def setInterpolation(self, *args):
        r"""setInterpolation(BlackVarianceSurface self, std::string const & interpolator="")"""
        return _QuantLib.BlackVarianceSurface_setInterpolation(self, *args)
    __swig_destroy__ = _QuantLib.delete_BlackVarianceSurface

# Register BlackVarianceSurface in _QuantLib:
_QuantLib.BlackVarianceSurface_swigregister(BlackVarianceSurface)
class LocalConstantVol(LocalVolTermStructure):
    r"""Proxy of C++ LocalConstantVol class."""

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

    def __init__(self, *args):
        r"""
        __init__(LocalConstantVol self, Date referenceDate, Volatility volatility, DayCounter dayCounter) -> LocalConstantVol
        __init__(LocalConstantVol self, Date referenceDate, QuoteHandle volatility, DayCounter dayCounter) -> LocalConstantVol
        __init__(LocalConstantVol self, Integer settlementDays, Calendar calendar, Volatility volatility, DayCounter dayCounter) -> LocalConstantVol
        __init__(LocalConstantVol self, Integer settlementDays, Calendar calendar, QuoteHandle volatility, DayCounter dayCounter) -> LocalConstantVol
        """
        _QuantLib.LocalConstantVol_swiginit(self, _QuantLib.new_LocalConstantVol(*args))
    __swig_destroy__ = _QuantLib.delete_LocalConstantVol

# Register LocalConstantVol in _QuantLib:
_QuantLib.LocalConstantVol_swigregister(LocalConstantVol)
class LocalVolSurface(LocalVolTermStructure):
    r"""Proxy of C++ LocalVolSurface class."""

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

    def __init__(self, *args):
        r"""
        __init__(LocalVolSurface self, BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, QuoteHandle underlying) -> LocalVolSurface
        __init__(LocalVolSurface self, BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, Real underlying) -> LocalVolSurface
        """
        _QuantLib.LocalVolSurface_swiginit(self, _QuantLib.new_LocalVolSurface(*args))
    __swig_destroy__ = _QuantLib.delete_LocalVolSurface

# Register LocalVolSurface in _QuantLib:
_QuantLib.LocalVolSurface_swigregister(LocalVolSurface)
class NoExceptLocalVolSurface(LocalVolSurface):
    r"""Proxy of C++ NoExceptLocalVolSurface class."""

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

    def __init__(self, *args):
        r"""
        __init__(NoExceptLocalVolSurface self, BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, QuoteHandle underlying, Real illegalLocalVolOverwrite) -> NoExceptLocalVolSurface
        __init__(NoExceptLocalVolSurface self, BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, Real underlying, Real illegalLocalVolOverwrite) -> NoExceptLocalVolSurface
        """
        _QuantLib.NoExceptLocalVolSurface_swiginit(self, _QuantLib.new_NoExceptLocalVolSurface(*args))
    __swig_destroy__ = _QuantLib.delete_NoExceptLocalVolSurface

# Register NoExceptLocalVolSurface in _QuantLib:
_QuantLib.NoExceptLocalVolSurface_swigregister(NoExceptLocalVolSurface)
class ConstantOptionletVolatility(OptionletVolatilityStructure):
    r"""Proxy of C++ ConstantOptionletVolatility class."""

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

    def __init__(self, *args):
        r"""
        __init__(ConstantOptionletVolatility self, Date referenceDate, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantOptionletVolatility
        __init__(ConstantOptionletVolatility self, Date referenceDate, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantOptionletVolatility
        __init__(ConstantOptionletVolatility self, Natural settlementDays, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantOptionletVolatility
        __init__(ConstantOptionletVolatility self, Natural settlementDays, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantOptionletVolatility
        """
        _QuantLib.ConstantOptionletVolatility_swiginit(self, _QuantLib.new_ConstantOptionletVolatility(*args))
    __swig_destroy__ = _QuantLib.delete_ConstantOptionletVolatility

# Register ConstantOptionletVolatility in _QuantLib:
_QuantLib.ConstantOptionletVolatility_swigregister(ConstantOptionletVolatility)
class ConstantSwaptionVolatility(SwaptionVolatilityStructure):
    r"""Proxy of C++ ConstantSwaptionVolatility class."""

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

    def __init__(self, *args):
        r"""
        __init__(ConstantSwaptionVolatility self, Natural settlementDays, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantSwaptionVolatility
        __init__(ConstantSwaptionVolatility self, Date referenceDate, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantSwaptionVolatility
        __init__(ConstantSwaptionVolatility self, Natural settlementDays, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantSwaptionVolatility
        __init__(ConstantSwaptionVolatility self, Date referenceDate, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> ConstantSwaptionVolatility
        """
        _QuantLib.ConstantSwaptionVolatility_swiginit(self, _QuantLib.new_ConstantSwaptionVolatility(*args))
    __swig_destroy__ = _QuantLib.delete_ConstantSwaptionVolatility

# Register ConstantSwaptionVolatility in _QuantLib:
_QuantLib.ConstantSwaptionVolatility_swigregister(ConstantSwaptionVolatility)
class SwaptionVolatilityDiscrete(SwaptionVolatilityStructure):
    r"""Proxy of C++ SwaptionVolatilityDiscrete class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def optionTenors(self):
        r"""optionTenors(SwaptionVolatilityDiscrete self) -> PeriodVector"""
        return _QuantLib.SwaptionVolatilityDiscrete_optionTenors(self)

    def optionDates(self):
        r"""optionDates(SwaptionVolatilityDiscrete self) -> DateVector"""
        return _QuantLib.SwaptionVolatilityDiscrete_optionDates(self)

    def optionTimes(self):
        r"""optionTimes(SwaptionVolatilityDiscrete self) -> DoubleVector"""
        return _QuantLib.SwaptionVolatilityDiscrete_optionTimes(self)

    def swapTenors(self):
        r"""swapTenors(SwaptionVolatilityDiscrete self) -> PeriodVector"""
        return _QuantLib.SwaptionVolatilityDiscrete_swapTenors(self)

    def swapLengths(self):
        r"""swapLengths(SwaptionVolatilityDiscrete self) -> DoubleVector"""
        return _QuantLib.SwaptionVolatilityDiscrete_swapLengths(self)

    def optionDateFromTime(self, optionTime):
        r"""optionDateFromTime(SwaptionVolatilityDiscrete self, Time optionTime) -> Date"""
        return _QuantLib.SwaptionVolatilityDiscrete_optionDateFromTime(self, optionTime)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityDiscrete

# Register SwaptionVolatilityDiscrete in _QuantLib:
_QuantLib.SwaptionVolatilityDiscrete_swigregister(SwaptionVolatilityDiscrete)
class SwaptionVolatilityMatrix(SwaptionVolatilityDiscrete):
    r"""Proxy of C++ SwaptionVolatilityMatrix class."""

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

    def __init__(self, *args):
        r"""
        __init__(SwaptionVolatilityMatrix self, Date referenceDate, Calendar calendar, BusinessDayConvention bdc, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, Matrix shifts=Matrix()) -> SwaptionVolatilityMatrix
        __init__(SwaptionVolatilityMatrix self, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, PeriodVector swapTenors, QuoteHandleVectorVector vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const & shifts=std::vector< std::vector< Real > >()) -> SwaptionVolatilityMatrix
        __init__(SwaptionVolatilityMatrix self, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, PeriodVector swapTenors, Matrix vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, Matrix shifts=Matrix()) -> SwaptionVolatilityMatrix
        __init__(SwaptionVolatilityMatrix self, Date referenceDate, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, Matrix shifts=Matrix()) -> SwaptionVolatilityMatrix
        """
        _QuantLib.SwaptionVolatilityMatrix_swiginit(self, _QuantLib.new_SwaptionVolatilityMatrix(*args))

    def locate(self, *args):
        r"""
        locate(SwaptionVolatilityMatrix self, Date optionDate, Period swapTenor) -> UnsignedIntPair
        locate(SwaptionVolatilityMatrix self, Time optionTime, Time swapLength) -> UnsignedIntPair
        """
        return _QuantLib.SwaptionVolatilityMatrix_locate(self, *args)

    def volatilityType(self):
        r"""volatilityType(SwaptionVolatilityMatrix self) -> VolatilityType"""
        return _QuantLib.SwaptionVolatilityMatrix_volatilityType(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityMatrix

# Register SwaptionVolatilityMatrix in _QuantLib:
_QuantLib.SwaptionVolatilityMatrix_swigregister(SwaptionVolatilityMatrix)
class SabrSmileSection(SmileSection):
    r"""Proxy of C++ SabrSmileSection class."""

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

    def __init__(self, *args):
        r"""
        __init__(SabrSmileSection self, Date d, Rate forward, DoubleVector sabrParameters, Date referenceDate=Date(), DayCounter dc=Actual365Fixed(), Real shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> SabrSmileSection
        __init__(SabrSmileSection self, Date d, Rate forward, DoubleVector sabrParameters, DayCounter dc, Real shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> SabrSmileSection
        __init__(SabrSmileSection self, Time timeToExpiry, Rate forward, DoubleVector sabrParameters, Real shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> SabrSmileSection
        """
        _QuantLib.SabrSmileSection_swiginit(self, _QuantLib.new_SabrSmileSection(*args))

    def alpha(self):
        r"""alpha(SabrSmileSection self) -> Real"""
        return _QuantLib.SabrSmileSection_alpha(self)

    def beta(self):
        r"""beta(SabrSmileSection self) -> Real"""
        return _QuantLib.SabrSmileSection_beta(self)

    def nu(self):
        r"""nu(SabrSmileSection self) -> Real"""
        return _QuantLib.SabrSmileSection_nu(self)

    def rho(self):
        r"""rho(SabrSmileSection self) -> Real"""
        return _QuantLib.SabrSmileSection_rho(self)
    __swig_destroy__ = _QuantLib.delete_SabrSmileSection

# Register SabrSmileSection in _QuantLib:
_QuantLib.SabrSmileSection_swigregister(SabrSmileSection)
class SviSmileSection(SmileSection):
    r"""Proxy of C++ SviSmileSection class."""

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

    def __init__(self, *args):
        r"""
        __init__(SviSmileSection self, Time timeToExpiry, Rate forward, DoubleVector sviParameters) -> SviSmileSection
        __init__(SviSmileSection self, Date d, Rate forward, DoubleVector sviParameters, DayCounter dc=Actual365Fixed()) -> SviSmileSection
        """
        _QuantLib.SviSmileSection_swiginit(self, _QuantLib.new_SviSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_SviSmileSection

# Register SviSmileSection in _QuantLib:
_QuantLib.SviSmileSection_swigregister(SviSmileSection)
class SviInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ SviInterpolatedSmileSection class."""

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

    def __init__(self, *args):
        r"""
        __init__(SviInterpolatedSmileSection self, Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real a, Real b, Real sigma, Real rho, Real m, bool aIsFixed, bool bIsFixed, bool sigmaIsFixed, bool rhoIsFixed, bool mIsFixed, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> SviInterpolatedSmileSection
        __init__(SviInterpolatedSmileSection self, Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real a, Real b, Real sigma, Real rho, Real m, bool isAFixed, bool isBFixed, bool isSigmaFixed, bool isRhoFixed, bool isMFixed, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> SviInterpolatedSmileSection
        """
        _QuantLib.SviInterpolatedSmileSection_swiginit(self, _QuantLib.new_SviInterpolatedSmileSection(*args))

    def a(self):
        r"""a(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_a(self)

    def b(self):
        r"""b(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_b(self)

    def sigma(self):
        r"""sigma(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_sigma(self)

    def rho(self):
        r"""rho(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_rho(self)

    def m(self):
        r"""m(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_m(self)

    def rmsError(self):
        r"""rmsError(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        r"""maxError(SviInterpolatedSmileSection self) -> Real"""
        return _QuantLib.SviInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        r"""endCriteria(SviInterpolatedSmileSection self) -> EndCriteria::Type"""
        return _QuantLib.SviInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_SviInterpolatedSmileSection

# Register SviInterpolatedSmileSection in _QuantLib:
_QuantLib.SviInterpolatedSmileSection_swigregister(SviInterpolatedSmileSection)
class SwaptionVolatilityCube(SwaptionVolatilityDiscrete):
    r"""Proxy of C++ SwaptionVolatilityCube class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def atmStrike(self, optionDate, swapTenor):
        r"""atmStrike(SwaptionVolatilityCube self, Date optionDate, Period swapTenor) -> Rate"""
        return _QuantLib.SwaptionVolatilityCube_atmStrike(self, optionDate, swapTenor)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityCube

# Register SwaptionVolatilityCube in _QuantLib:
_QuantLib.SwaptionVolatilityCube_swigregister(SwaptionVolatilityCube)
class SwaptionVolCube1(SwaptionVolatilityCube):
    r"""Proxy of C++ SwaptionVolCube1 class."""

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

    def __init__(self, *args):
        r"""__init__(SwaptionVolCube1 self, SwaptionVolatilityStructureHandle atmVolStructure, PeriodVector optionTenors, PeriodVector swapTenors, DoubleVector strikeSpreads, QuoteHandleVectorVector volSpreads, ext::shared_ptr< SwapIndex > const & swapIndex, ext::shared_ptr< SwapIndex > const & shortSwapIndex, bool vegaWeightedSmileFit, QuoteHandleVectorVector parametersGuess, BoolVector isParameterFixed, bool isAtmCalibrated, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), Real maxErrorTolerance=Null< Real >(), ext::shared_ptr< OptimizationMethod > const & optMethod=ext::shared_ptr< OptimizationMethod >(), Real const errorAccept=Null< Real >(), bool const useMaxError=False, Size const maxGuesses=50, bool const backwardFlat=False, Real const cutoffStrike=0.0001) -> SwaptionVolCube1"""
        _QuantLib.SwaptionVolCube1_swiginit(self, _QuantLib.new_SwaptionVolCube1(*args))

    def sparseSabrParameters(self):
        r"""sparseSabrParameters(SwaptionVolCube1 self) -> Matrix"""
        return _QuantLib.SwaptionVolCube1_sparseSabrParameters(self)

    def denseSabrParameters(self):
        r"""denseSabrParameters(SwaptionVolCube1 self) -> Matrix"""
        return _QuantLib.SwaptionVolCube1_denseSabrParameters(self)

    def marketVolCube(self):
        r"""marketVolCube(SwaptionVolCube1 self) -> Matrix"""
        return _QuantLib.SwaptionVolCube1_marketVolCube(self)

    def volCubeAtmCalibrated(self):
        r"""volCubeAtmCalibrated(SwaptionVolCube1 self) -> Matrix"""
        return _QuantLib.SwaptionVolCube1_volCubeAtmCalibrated(self)

    def smileSection(self, *args):
        r"""
        smileSection(SwaptionVolCube1 self, Time optionTime, Time swapLength, bool extr=False) -> ext::shared_ptr< SabrSmileSection >
        smileSection(SwaptionVolCube1 self, Period optionTenor, Period swapTenor, bool extr=False) -> ext::shared_ptr< SabrSmileSection >
        """
        return _QuantLib.SwaptionVolCube1_smileSection(self, *args)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolCube1

# Register SwaptionVolCube1 in _QuantLib:
_QuantLib.SwaptionVolCube1_swigregister(SwaptionVolCube1)
class SwaptionVolCube2(SwaptionVolatilityCube):
    r"""Proxy of C++ SwaptionVolCube2 class."""

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

    def __init__(self, atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndex, shortSwapIndex, vegaWeightedSmileFit):
        r"""__init__(SwaptionVolCube2 self, SwaptionVolatilityStructureHandle atmVolStructure, PeriodVector optionTenors, PeriodVector swapTenors, DoubleVector strikeSpreads, QuoteHandleVectorVector volSpreads, ext::shared_ptr< SwapIndex > const & swapIndex, ext::shared_ptr< SwapIndex > const & shortSwapIndex, bool vegaWeightedSmileFit) -> SwaptionVolCube2"""
        _QuantLib.SwaptionVolCube2_swiginit(self, _QuantLib.new_SwaptionVolCube2(atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndex, shortSwapIndex, vegaWeightedSmileFit))
    __swig_destroy__ = _QuantLib.delete_SwaptionVolCube2

# Register SwaptionVolCube2 in _QuantLib:
_QuantLib.SwaptionVolCube2_swigregister(SwaptionVolCube2)
class ConstantYoYOptionletVolatility(YoYOptionletVolatilitySurface):
    r"""Proxy of C++ ConstantYoYOptionletVolatility class."""

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

    def __init__(self, volatility, settlementDays, cal, bdc, dc, observationLag, frequency, indexIsInterpolated, minStrike=-1.0, maxStrike=100.0):
        r"""__init__(ConstantYoYOptionletVolatility self, Volatility volatility, Natural settlementDays, Calendar cal, BusinessDayConvention bdc, DayCounter dc, Period observationLag, Frequency frequency, bool indexIsInterpolated, Real minStrike=-1.0, Real maxStrike=100.0) -> ConstantYoYOptionletVolatility"""
        _QuantLib.ConstantYoYOptionletVolatility_swiginit(self, _QuantLib.new_ConstantYoYOptionletVolatility(volatility, settlementDays, cal, bdc, dc, observationLag, frequency, indexIsInterpolated, minStrike, maxStrike))
    __swig_destroy__ = _QuantLib.delete_ConstantYoYOptionletVolatility

# Register ConstantYoYOptionletVolatility in _QuantLib:
_QuantLib.ConstantYoYOptionletVolatility_swigregister(ConstantYoYOptionletVolatility)
class FlatSmileSection(SmileSection):
    r"""Proxy of C++ FlatSmileSection class."""

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

    def __init__(self, *args):
        r"""
        __init__(FlatSmileSection self, Date d, Volatility vol, DayCounter dc, Date referenceDate=Date(), Real atmLevel=Null< Rate >(), VolatilityType type=ShiftedLognormal, Real shift=0.0) -> FlatSmileSection
        __init__(FlatSmileSection self, Time exerciseTime, Volatility vol, DayCounter dc, Real atmLevel=Null< Rate >(), VolatilityType type=ShiftedLognormal, Real shift=0.0) -> FlatSmileSection
        """
        _QuantLib.FlatSmileSection_swiginit(self, _QuantLib.new_FlatSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_FlatSmileSection

# Register FlatSmileSection in _QuantLib:
_QuantLib.FlatSmileSection_swigregister(FlatSmileSection)
class LinearInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ InterpolatedSmileSection< Linear > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LinearInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, Linear interpolator=Linear(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> LinearInterpolatedSmileSection
        __init__(LinearInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, Linear interpolator=Linear(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> LinearInterpolatedSmileSection
        __init__(LinearInterpolatedSmileSection self, Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), Linear interpolator=Linear(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> LinearInterpolatedSmileSection
        __init__(LinearInterpolatedSmileSection self, Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), Linear interpolator=Linear(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> LinearInterpolatedSmileSection
        """
        _QuantLib.LinearInterpolatedSmileSection_swiginit(self, _QuantLib.new_LinearInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_LinearInterpolatedSmileSection

# Register LinearInterpolatedSmileSection in _QuantLib:
_QuantLib.LinearInterpolatedSmileSection_swigregister(LinearInterpolatedSmileSection)
class CubicInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ InterpolatedSmileSection< Cubic > class."""

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

    def __init__(self, *args):
        r"""
        __init__(CubicInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, Cubic interpolator=Cubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> CubicInterpolatedSmileSection
        __init__(CubicInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, Cubic interpolator=Cubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> CubicInterpolatedSmileSection
        __init__(CubicInterpolatedSmileSection self, Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), Cubic interpolator=Cubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> CubicInterpolatedSmileSection
        __init__(CubicInterpolatedSmileSection self, Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), Cubic interpolator=Cubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> CubicInterpolatedSmileSection
        """
        _QuantLib.CubicInterpolatedSmileSection_swiginit(self, _QuantLib.new_CubicInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_CubicInterpolatedSmileSection

# Register CubicInterpolatedSmileSection in _QuantLib:
_QuantLib.CubicInterpolatedSmileSection_swigregister(CubicInterpolatedSmileSection)
class MonotonicCubicInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ InterpolatedSmileSection< MonotonicCubic > class."""

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

    def __init__(self, *args):
        r"""
        __init__(MonotonicCubicInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, MonotonicCubic interpolator=MonotonicCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> MonotonicCubicInterpolatedSmileSection
        __init__(MonotonicCubicInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, MonotonicCubic interpolator=MonotonicCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> MonotonicCubicInterpolatedSmileSection
        __init__(MonotonicCubicInterpolatedSmileSection self, Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), MonotonicCubic interpolator=MonotonicCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> MonotonicCubicInterpolatedSmileSection
        __init__(MonotonicCubicInterpolatedSmileSection self, Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), MonotonicCubic interpolator=MonotonicCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> MonotonicCubicInterpolatedSmileSection
        """
        _QuantLib.MonotonicCubicInterpolatedSmileSection_swiginit(self, _QuantLib.new_MonotonicCubicInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicInterpolatedSmileSection

# Register MonotonicCubicInterpolatedSmileSection in _QuantLib:
_QuantLib.MonotonicCubicInterpolatedSmileSection_swigregister(MonotonicCubicInterpolatedSmileSection)
class SplineCubicInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ InterpolatedSmileSection< SplineCubic > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SplineCubicInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, SplineCubic interpolator=SplineCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SplineCubicInterpolatedSmileSection
        __init__(SplineCubicInterpolatedSmileSection self, Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, SplineCubic interpolator=SplineCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SplineCubicInterpolatedSmileSection
        __init__(SplineCubicInterpolatedSmileSection self, Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), SplineCubic interpolator=SplineCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SplineCubicInterpolatedSmileSection
        __init__(SplineCubicInterpolatedSmileSection self, Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), SplineCubic interpolator=SplineCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SplineCubicInterpolatedSmileSection
        """
        _QuantLib.SplineCubicInterpolatedSmileSection_swiginit(self, _QuantLib.new_SplineCubicInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_SplineCubicInterpolatedSmileSection

# Register SplineCubicInterpolatedSmileSection in _QuantLib:
_QuantLib.SplineCubicInterpolatedSmileSection_swigregister(SplineCubicInterpolatedSmileSection)
class KahaleSmileSection(SmileSection):
    r"""Proxy of C++ KahaleSmileSection class."""

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

    def __init__(self, *args):
        r"""__init__(KahaleSmileSection self, ext::shared_ptr< SmileSection > const source, Real const atm=Null< Real >(), bool const interpolate=False, bool const exponentialExtrapolation=False, bool const deleteArbitragePoints=False, DoubleVector moneynessGrid=std::vector< Real >(), Real const gap=1.0E-5, int const forcedLeftIndex=-1, int const forcedRightIndex=QL_MAX_INTEGER) -> KahaleSmileSection"""
        _QuantLib.KahaleSmileSection_swiginit(self, _QuantLib.new_KahaleSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_KahaleSmileSection

# Register KahaleSmileSection in _QuantLib:
_QuantLib.KahaleSmileSection_swigregister(KahaleSmileSection)
class ZabrShortMaturityLognormal(object):
    r"""Proxy of C++ ZabrShortMaturityLognormal class."""

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

    def __init__(self):
        r"""__init__(ZabrShortMaturityLognormal self) -> ZabrShortMaturityLognormal"""
        _QuantLib.ZabrShortMaturityLognormal_swiginit(self, _QuantLib.new_ZabrShortMaturityLognormal())
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityLognormal

# Register ZabrShortMaturityLognormal in _QuantLib:
_QuantLib.ZabrShortMaturityLognormal_swigregister(ZabrShortMaturityLognormal)
class ZabrShortMaturityNormal(object):
    r"""Proxy of C++ ZabrShortMaturityNormal class."""

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

    def __init__(self):
        r"""__init__(ZabrShortMaturityNormal self) -> ZabrShortMaturityNormal"""
        _QuantLib.ZabrShortMaturityNormal_swiginit(self, _QuantLib.new_ZabrShortMaturityNormal())
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityNormal

# Register ZabrShortMaturityNormal in _QuantLib:
_QuantLib.ZabrShortMaturityNormal_swigregister(ZabrShortMaturityNormal)
class ZabrLocalVolatility(object):
    r"""Proxy of C++ ZabrLocalVolatility class."""

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

    def __init__(self):
        r"""__init__(ZabrLocalVolatility self) -> ZabrLocalVolatility"""
        _QuantLib.ZabrLocalVolatility_swiginit(self, _QuantLib.new_ZabrLocalVolatility())
    __swig_destroy__ = _QuantLib.delete_ZabrLocalVolatility

# Register ZabrLocalVolatility in _QuantLib:
_QuantLib.ZabrLocalVolatility_swigregister(ZabrLocalVolatility)
class ZabrFullFd(object):
    r"""Proxy of C++ ZabrFullFd class."""

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

    def __init__(self):
        r"""__init__(ZabrFullFd self) -> ZabrFullFd"""
        _QuantLib.ZabrFullFd_swiginit(self, _QuantLib.new_ZabrFullFd())
    __swig_destroy__ = _QuantLib.delete_ZabrFullFd

# Register ZabrFullFd in _QuantLib:
_QuantLib.ZabrFullFd_swigregister(ZabrFullFd)
class ZabrShortMaturityLognormalSmileSection(SmileSection):
    r"""Proxy of C++ ZabrSmileSection< ZabrShortMaturityLognormal > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrShortMaturityLognormalSmileSection self, Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrShortMaturityLognormalSmileSection
        __init__(ZabrShortMaturityLognormalSmileSection self, Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrShortMaturityLognormalSmileSection
        """
        _QuantLib.ZabrShortMaturityLognormalSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityLognormalSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityLognormalSmileSection

# Register ZabrShortMaturityLognormalSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityLognormalSmileSection_swigregister(ZabrShortMaturityLognormalSmileSection)
class ZabrShortMaturityNormalSmileSection(SmileSection):
    r"""Proxy of C++ ZabrSmileSection< ZabrShortMaturityNormal > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrShortMaturityNormalSmileSection self, Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrShortMaturityNormalSmileSection
        __init__(ZabrShortMaturityNormalSmileSection self, Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrShortMaturityNormalSmileSection
        """
        _QuantLib.ZabrShortMaturityNormalSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityNormalSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityNormalSmileSection

# Register ZabrShortMaturityNormalSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityNormalSmileSection_swigregister(ZabrShortMaturityNormalSmileSection)
class ZabrLocalVolatilitySmileSection(SmileSection):
    r"""Proxy of C++ ZabrSmileSection< ZabrLocalVolatility > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrLocalVolatilitySmileSection self, Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrLocalVolatilitySmileSection
        __init__(ZabrLocalVolatilitySmileSection self, Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrLocalVolatilitySmileSection
        """
        _QuantLib.ZabrLocalVolatilitySmileSection_swiginit(self, _QuantLib.new_ZabrLocalVolatilitySmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrLocalVolatilitySmileSection

# Register ZabrLocalVolatilitySmileSection in _QuantLib:
_QuantLib.ZabrLocalVolatilitySmileSection_swigregister(ZabrLocalVolatilitySmileSection)
class ZabrFullFdSmileSection(SmileSection):
    r"""Proxy of C++ ZabrSmileSection< ZabrFullFd > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrFullFdSmileSection self, Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrFullFdSmileSection
        __init__(ZabrFullFdSmileSection self, Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5) -> ZabrFullFdSmileSection
        """
        _QuantLib.ZabrFullFdSmileSection_swiginit(self, _QuantLib.new_ZabrFullFdSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrFullFdSmileSection

# Register ZabrFullFdSmileSection in _QuantLib:
_QuantLib.ZabrFullFdSmileSection_swigregister(ZabrFullFdSmileSection)
class ZabrShortMaturityLognormalInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrShortMaturityLognormalInterpolatedSmileSection self, Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrShortMaturityLognormalInterpolatedSmileSection
        __init__(ZabrShortMaturityLognormalInterpolatedSmileSection self, Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrShortMaturityLognormalInterpolatedSmileSection
        """
        _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityLognormalInterpolatedSmileSection(*args))

    def alpha(self):
        r"""alpha(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_alpha(self)

    def beta(self):
        r"""beta(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_beta(self)

    def nu(self):
        r"""nu(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_nu(self)

    def rho(self):
        r"""rho(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_rho(self)

    def rmsError(self):
        r"""rmsError(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        r"""maxError(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        r"""endCriteria(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> EndCriteria::Type"""
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityLognormalInterpolatedSmileSection

# Register ZabrShortMaturityLognormalInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister(ZabrShortMaturityLognormalInterpolatedSmileSection)
class ZabrShortMaturityNormalInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrShortMaturityNormalInterpolatedSmileSection self, Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrShortMaturityNormalInterpolatedSmileSection
        __init__(ZabrShortMaturityNormalInterpolatedSmileSection self, Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrShortMaturityNormalInterpolatedSmileSection
        """
        _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityNormalInterpolatedSmileSection(*args))

    def alpha(self):
        r"""alpha(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_alpha(self)

    def beta(self):
        r"""beta(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_beta(self)

    def nu(self):
        r"""nu(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_nu(self)

    def rho(self):
        r"""rho(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_rho(self)

    def rmsError(self):
        r"""rmsError(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        r"""maxError(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        r"""endCriteria(ZabrShortMaturityNormalInterpolatedSmileSection self) -> EndCriteria::Type"""
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityNormalInterpolatedSmileSection

# Register ZabrShortMaturityNormalInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_swigregister(ZabrShortMaturityNormalInterpolatedSmileSection)
class ZabrLocalVolatilityInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ ZabrInterpolatedSmileSection< ZabrLocalVolatility > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrLocalVolatilityInterpolatedSmileSection self, Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrLocalVolatilityInterpolatedSmileSection
        __init__(ZabrLocalVolatilityInterpolatedSmileSection self, Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrLocalVolatilityInterpolatedSmileSection
        """
        _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrLocalVolatilityInterpolatedSmileSection(*args))

    def alpha(self):
        r"""alpha(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_alpha(self)

    def beta(self):
        r"""beta(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_beta(self)

    def nu(self):
        r"""nu(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_nu(self)

    def rho(self):
        r"""rho(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_rho(self)

    def rmsError(self):
        r"""rmsError(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        r"""maxError(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        r"""endCriteria(ZabrLocalVolatilityInterpolatedSmileSection self) -> EndCriteria::Type"""
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrLocalVolatilityInterpolatedSmileSection

# Register ZabrLocalVolatilityInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_swigregister(ZabrLocalVolatilityInterpolatedSmileSection)
class ZabrFullFdInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ ZabrInterpolatedSmileSection< ZabrFullFd > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZabrFullFdInterpolatedSmileSection self, Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrFullFdInterpolatedSmileSection
        __init__(ZabrFullFdInterpolatedSmileSection self, Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> ZabrFullFdInterpolatedSmileSection
        """
        _QuantLib.ZabrFullFdInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrFullFdInterpolatedSmileSection(*args))

    def alpha(self):
        r"""alpha(ZabrFullFdInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_alpha(self)

    def beta(self):
        r"""beta(ZabrFullFdInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_beta(self)

    def nu(self):
        r"""nu(ZabrFullFdInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_nu(self)

    def rho(self):
        r"""rho(ZabrFullFdInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_rho(self)

    def rmsError(self):
        r"""rmsError(ZabrFullFdInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        r"""maxError(ZabrFullFdInterpolatedSmileSection self) -> Real"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        r"""endCriteria(ZabrFullFdInterpolatedSmileSection self) -> EndCriteria::Type"""
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrFullFdInterpolatedSmileSection

# Register ZabrFullFdInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrFullFdInterpolatedSmileSection_swigregister(ZabrFullFdInterpolatedSmileSection)
class NoArbSabrSmileSection(SmileSection):
    r"""Proxy of C++ NoArbSabrSmileSection class."""

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

    def __init__(self, *args):
        r"""
        __init__(NoArbSabrSmileSection self, Time timeToExpiry, Rate forward, DoubleVector sabrParameters, Real const shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> NoArbSabrSmileSection
        __init__(NoArbSabrSmileSection self, Date d, Rate forward, DoubleVector sabrParameters, DayCounter dc=Actual365Fixed(), Real const shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> NoArbSabrSmileSection
        """
        _QuantLib.NoArbSabrSmileSection_swiginit(self, _QuantLib.new_NoArbSabrSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_NoArbSabrSmileSection

# Register NoArbSabrSmileSection in _QuantLib:
_QuantLib.NoArbSabrSmileSection_swigregister(NoArbSabrSmileSection)
class NoArbSabrInterpolatedSmileSection(SmileSection):
    r"""Proxy of C++ NoArbSabrInterpolatedSmileSection class."""

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

    def __init__(self, *args):
        r"""
        __init__(NoArbSabrInterpolatedSmileSection self, Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> NoArbSabrInterpolatedSmileSection
        __init__(NoArbSabrInterpolatedSmileSection self, Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed()) -> NoArbSabrInterpolatedSmileSection
        """
        _QuantLib.NoArbSabrInterpolatedSmileSection_swiginit(self, _QuantLib.new_NoArbSabrInterpolatedSmileSection(*args))

    def alpha(self):
        r"""alpha(NoArbSabrInterpolatedSmileSection self) -> Real"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_alpha(self)

    def beta(self):
        r"""beta(NoArbSabrInterpolatedSmileSection self) -> Real"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_beta(self)

    def nu(self):
        r"""nu(NoArbSabrInterpolatedSmileSection self) -> Real"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_nu(self)

    def rho(self):
        r"""rho(NoArbSabrInterpolatedSmileSection self) -> Real"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_rho(self)

    def rmsError(self):
        r"""rmsError(NoArbSabrInterpolatedSmileSection self) -> Real"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        r"""maxError(NoArbSabrInterpolatedSmileSection self) -> Real"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        r"""endCriteria(NoArbSabrInterpolatedSmileSection self) -> EndCriteria::Type"""
        return _QuantLib.NoArbSabrInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_NoArbSabrInterpolatedSmileSection

# Register NoArbSabrInterpolatedSmileSection in _QuantLib:
_QuantLib.NoArbSabrInterpolatedSmileSection_swigregister(NoArbSabrInterpolatedSmileSection)

def sabrVolatility(*args):
    r"""sabrVolatility(Rate strike, Rate forward, Time expiryTime, Real alpha, Real beta, Real nu, Real rho, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> Real"""
    return _QuantLib.sabrVolatility(*args)

def shiftedSabrVolatility(*args):
    r"""shiftedSabrVolatility(Rate strike, Rate forward, Time expiryTime, Real alpha, Real beta, Real nu, Real rho, Real shift, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> Real"""
    return _QuantLib.shiftedSabrVolatility(*args)

def sabrFlochKennedyVolatility(strike, forward, expiryTime, alpha, beta, nu, rho):
    r"""sabrFlochKennedyVolatility(Rate strike, Rate forward, Time expiryTime, Real alpha, Real beta, Real nu, Real rho) -> Real"""
    return _QuantLib.sabrFlochKennedyVolatility(strike, forward, expiryTime, alpha, beta, nu, rho)
class CalibrationErrorTuple(object):
    r"""Proxy of C++ ext::tuple< Real,Real,Real > class."""

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

    def __init__(self, arg2, arg3, arg4):
        r"""__init__(CalibrationErrorTuple self, double arg2, double arg3, double arg4) -> CalibrationErrorTuple"""
        _QuantLib.CalibrationErrorTuple_swiginit(self, _QuantLib.new_CalibrationErrorTuple(arg2, arg3, arg4))

    def first(self):
        r"""first(CalibrationErrorTuple self) -> double"""
        return _QuantLib.CalibrationErrorTuple_first(self)

    def second(self):
        r"""second(CalibrationErrorTuple self) -> double"""
        return _QuantLib.CalibrationErrorTuple_second(self)

    def third(self):
        r"""third(CalibrationErrorTuple self) -> double"""
        return _QuantLib.CalibrationErrorTuple_third(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationErrorTuple

# Register CalibrationErrorTuple in _QuantLib:
_QuantLib.CalibrationErrorTuple_swigregister(CalibrationErrorTuple)
class AndreasenHugeVolatilityInterpl(Observable):
    r"""Proxy of C++ AndreasenHugeVolatilityInterpl class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PiecewiseConstant = _QuantLib.AndreasenHugeVolatilityInterpl_PiecewiseConstant
    
    Linear = _QuantLib.AndreasenHugeVolatilityInterpl_Linear
    
    CubicSpline = _QuantLib.AndreasenHugeVolatilityInterpl_CubicSpline
    
    Call = _QuantLib.AndreasenHugeVolatilityInterpl_Call
    
    Put = _QuantLib.AndreasenHugeVolatilityInterpl_Put
    
    CallPut = _QuantLib.AndreasenHugeVolatilityInterpl_CallPut
    

    def __init__(self, *args):
        r"""__init__(AndreasenHugeVolatilityInterpl self, CalibrationSet calibrationSet, QuoteHandle spot, YieldTermStructureHandle rTS, YieldTermStructureHandle qTS, AndreasenHugeVolatilityInterpl::InterpolationType interpolationType=CubicSpline, AndreasenHugeVolatilityInterpl::CalibrationType calibrationType=Call, Size nGridPoints=500, Real minStrike=Null< Real >(), Real maxStrike=Null< Real >(), ext::shared_ptr< OptimizationMethod > const & optimizationMethod=ext::shared_ptr< OptimizationMethod >(new LevenbergMarquardt), EndCriteria endCriteria=EndCriteria(500, 100, 1e-12, 1e-10, 1e-10)) -> AndreasenHugeVolatilityInterpl"""
        _QuantLib.AndreasenHugeVolatilityInterpl_swiginit(self, _QuantLib.new_AndreasenHugeVolatilityInterpl(*args))

    def maxDate(self):
        r"""maxDate(AndreasenHugeVolatilityInterpl self) -> Date"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_maxDate(self)

    def minStrike(self):
        r"""minStrike(AndreasenHugeVolatilityInterpl self) -> Real"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(AndreasenHugeVolatilityInterpl self) -> Real"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_maxStrike(self)

    def fwd(self, t):
        r"""fwd(AndreasenHugeVolatilityInterpl self, Time t) -> Real"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_fwd(self, t)

    def riskFreeRate(self):
        r"""riskFreeRate(AndreasenHugeVolatilityInterpl self) -> YieldTermStructureHandle"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_riskFreeRate(self)

    def calibrationError(self):
        r"""calibrationError(AndreasenHugeVolatilityInterpl self) -> CalibrationErrorTuple"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_calibrationError(self)

    def optionPrice(self, t, strike, optionType):
        r"""optionPrice(AndreasenHugeVolatilityInterpl self, Time t, Real strike, Option::Type optionType) -> Real"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_optionPrice(self, t, strike, optionType)

    def localVol(self, t, strike):
        r"""localVol(AndreasenHugeVolatilityInterpl self, Time t, Real strike) -> Volatility"""
        return _QuantLib.AndreasenHugeVolatilityInterpl_localVol(self, t, strike)
    __swig_destroy__ = _QuantLib.delete_AndreasenHugeVolatilityInterpl

# Register AndreasenHugeVolatilityInterpl in _QuantLib:
_QuantLib.AndreasenHugeVolatilityInterpl_swigregister(AndreasenHugeVolatilityInterpl)
class AndreasenHugeVolatilityAdapter(BlackVolTermStructure):
    r"""Proxy of C++ AndreasenHugeVolatilityAdapter class."""

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

    def __init__(self, volInterpl, eps=1e-6):
        r"""__init__(AndreasenHugeVolatilityAdapter self, ext::shared_ptr< AndreasenHugeVolatilityInterpl > const & volInterpl, Real eps=1e-6) -> AndreasenHugeVolatilityAdapter"""
        _QuantLib.AndreasenHugeVolatilityAdapter_swiginit(self, _QuantLib.new_AndreasenHugeVolatilityAdapter(volInterpl, eps))
    __swig_destroy__ = _QuantLib.delete_AndreasenHugeVolatilityAdapter

# Register AndreasenHugeVolatilityAdapter in _QuantLib:
_QuantLib.AndreasenHugeVolatilityAdapter_swigregister(AndreasenHugeVolatilityAdapter)
class AndreasenHugeLocalVolAdapter(LocalVolTermStructure):
    r"""Proxy of C++ AndreasenHugeLocalVolAdapter class."""

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

    def __init__(self, localVol):
        r"""__init__(AndreasenHugeLocalVolAdapter self, ext::shared_ptr< AndreasenHugeVolatilityInterpl > const & localVol) -> AndreasenHugeLocalVolAdapter"""
        _QuantLib.AndreasenHugeLocalVolAdapter_swiginit(self, _QuantLib.new_AndreasenHugeLocalVolAdapter(localVol))
    __swig_destroy__ = _QuantLib.delete_AndreasenHugeLocalVolAdapter

# Register AndreasenHugeLocalVolAdapter in _QuantLib:
_QuantLib.AndreasenHugeLocalVolAdapter_swigregister(AndreasenHugeLocalVolAdapter)
class HestonBlackVolSurface(BlackVolTermStructure):
    r"""Proxy of C++ HestonBlackVolSurface class."""

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

    def __init__(self, *args):
        r"""__init__(HestonBlackVolSurface self, HestonModelHandle hestonModel, AnalyticHestonEngine::ComplexLogFormula const cpxLogFormula=Gatheral, AnalyticHestonEngine_Integration integration=AnalyticHestonEngine::Integration::gaussLaguerre(164)) -> HestonBlackVolSurface"""
        _QuantLib.HestonBlackVolSurface_swiginit(self, _QuantLib.new_HestonBlackVolSurface(*args))
    __swig_destroy__ = _QuantLib.delete_HestonBlackVolSurface

# Register HestonBlackVolSurface in _QuantLib:
_QuantLib.HestonBlackVolSurface_swigregister(HestonBlackVolSurface)
class CmsMarket(object):
    r"""Proxy of C++ CmsMarket class."""

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

    def __init__(self, swapLengths, swapIndexes, iborIndex, bidAskSpreads, pricers, discountingTS):
        r"""__init__(CmsMarket self, PeriodVector swapLengths, SwapIndexVector swapIndexes, ext::shared_ptr< IborIndex > const & iborIndex, QuoteHandleVectorVector bidAskSpreads, CmsCouponPricerVector pricers, YieldTermStructureHandle discountingTS) -> CmsMarket"""
        _QuantLib.CmsMarket_swiginit(self, _QuantLib.new_CmsMarket(swapLengths, swapIndexes, iborIndex, bidAskSpreads, pricers, discountingTS))

    def reprice(self, volStructure, meanReversion):
        r"""reprice(CmsMarket self, SwaptionVolatilityStructureHandle volStructure, Real meanReversion)"""
        return _QuantLib.CmsMarket_reprice(self, volStructure, meanReversion)

    def swapTenors(self):
        r"""swapTenors(CmsMarket self) -> PeriodVector"""
        return _QuantLib.CmsMarket_swapTenors(self)

    def swapLengths(self):
        r"""swapLengths(CmsMarket self) -> PeriodVector"""
        return _QuantLib.CmsMarket_swapLengths(self)

    def impliedCmsSpreads(self):
        r"""impliedCmsSpreads(CmsMarket self) -> Matrix"""
        return _QuantLib.CmsMarket_impliedCmsSpreads(self)

    def spreadErrors(self):
        r"""spreadErrors(CmsMarket self) -> Matrix"""
        return _QuantLib.CmsMarket_spreadErrors(self)

    def browse(self):
        r"""browse(CmsMarket self) -> Matrix"""
        return _QuantLib.CmsMarket_browse(self)

    def weightedSpreadError(self, weights):
        r"""weightedSpreadError(CmsMarket self, Matrix weights) -> Real"""
        return _QuantLib.CmsMarket_weightedSpreadError(self, weights)

    def weightedSpotNpvError(self, weights):
        r"""weightedSpotNpvError(CmsMarket self, Matrix weights) -> Real"""
        return _QuantLib.CmsMarket_weightedSpotNpvError(self, weights)

    def weightedFwdNpvError(self, weights):
        r"""weightedFwdNpvError(CmsMarket self, Matrix weights) -> Real"""
        return _QuantLib.CmsMarket_weightedFwdNpvError(self, weights)

    def weightedSpreadErrors(self, weights):
        r"""weightedSpreadErrors(CmsMarket self, Matrix weights) -> Array"""
        return _QuantLib.CmsMarket_weightedSpreadErrors(self, weights)

    def weightedSpotNpvErrors(self, weights):
        r"""weightedSpotNpvErrors(CmsMarket self, Matrix weights) -> Array"""
        return _QuantLib.CmsMarket_weightedSpotNpvErrors(self, weights)

    def weightedFwdNpvErrors(self, weights):
        r"""weightedFwdNpvErrors(CmsMarket self, Matrix weights) -> Array"""
        return _QuantLib.CmsMarket_weightedFwdNpvErrors(self, weights)
    __swig_destroy__ = _QuantLib.delete_CmsMarket

# Register CmsMarket in _QuantLib:
_QuantLib.CmsMarket_swigregister(CmsMarket)
class CmsMarketCalibration(object):
    r"""Proxy of C++ CmsMarketCalibration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    OnSpread = _QuantLib.CmsMarketCalibration_OnSpread
    
    OnPrice = _QuantLib.CmsMarketCalibration_OnPrice
    
    OnForwardCmsPrice = _QuantLib.CmsMarketCalibration_OnForwardCmsPrice
    

    def __init__(self, volCube, cmsMarket, weights, calibrationType):
        r"""__init__(CmsMarketCalibration self, SwaptionVolatilityStructureHandle volCube, ext::shared_ptr< CmsMarket > & cmsMarket, Matrix weights, CmsMarketCalibration::CalibrationType calibrationType) -> CmsMarketCalibration"""
        _QuantLib.CmsMarketCalibration_swiginit(self, _QuantLib.new_CmsMarketCalibration(volCube, cmsMarket, weights, calibrationType))

    def compute(self, *args):
        r"""
        compute(CmsMarketCalibration self, ext::shared_ptr< EndCriteria > const & endCriteria, ext::shared_ptr< OptimizationMethod > const & method, Array guess, bool isMeanReversionFixed) -> Array
        compute(CmsMarketCalibration self, ext::shared_ptr< EndCriteria > const & endCriteria, ext::shared_ptr< OptimizationMethod > const & method, Matrix guess, bool isMeanReversionFixed, Real const meanReversionGuess=Null< Real >()) -> Matrix
        """
        return _QuantLib.CmsMarketCalibration_compute(self, *args)

    def computeParametric(self, *args):
        r"""computeParametric(CmsMarketCalibration self, ext::shared_ptr< EndCriteria > const & endCriteria, ext::shared_ptr< OptimizationMethod > const & method, Matrix guess, bool isMeanReversionFixed, Real const meanReversionGuess=Null< Real >()) -> Matrix"""
        return _QuantLib.CmsMarketCalibration_computeParametric(self, *args)

    def error(self):
        r"""error(CmsMarketCalibration self) -> Real"""
        return _QuantLib.CmsMarketCalibration_error(self)

    def endCriteria(self):
        r"""endCriteria(CmsMarketCalibration self) -> EndCriteria::Type"""
        return _QuantLib.CmsMarketCalibration_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_CmsMarketCalibration

# Register CmsMarketCalibration in _QuantLib:
_QuantLib.CmsMarketCalibration_swigregister(CmsMarketCalibration)
class StochasticProcess(Observable):
    r"""Proxy of C++ StochasticProcess class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def size(self):
        r"""size(StochasticProcess self) -> Size"""
        return _QuantLib.StochasticProcess_size(self)

    def factors(self):
        r"""factors(StochasticProcess self) -> Size"""
        return _QuantLib.StochasticProcess_factors(self)

    def initialValues(self):
        r"""initialValues(StochasticProcess self) -> Array"""
        return _QuantLib.StochasticProcess_initialValues(self)

    def drift(self, t, x):
        r"""drift(StochasticProcess self, Time t, Array x) -> Array"""
        return _QuantLib.StochasticProcess_drift(self, t, x)

    def diffusion(self, t, x):
        r"""diffusion(StochasticProcess self, Time t, Array x) -> Matrix"""
        return _QuantLib.StochasticProcess_diffusion(self, t, x)

    def expectation(self, t0, x0, dt):
        r"""expectation(StochasticProcess self, Time t0, Array x0, Time dt) -> Array"""
        return _QuantLib.StochasticProcess_expectation(self, t0, x0, dt)

    def stdDeviation(self, t0, x0, dt):
        r"""stdDeviation(StochasticProcess self, Time t0, Array x0, Time dt) -> Matrix"""
        return _QuantLib.StochasticProcess_stdDeviation(self, t0, x0, dt)

    def covariance(self, t0, x0, dt):
        r"""covariance(StochasticProcess self, Time t0, Array x0, Time dt) -> Matrix"""
        return _QuantLib.StochasticProcess_covariance(self, t0, x0, dt)

    def evolve(self, t0, x0, dt, dw):
        r"""evolve(StochasticProcess self, Time t0, Array x0, Time dt, Array dw) -> Array"""
        return _QuantLib.StochasticProcess_evolve(self, t0, x0, dt, dw)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess

# Register StochasticProcess in _QuantLib:
_QuantLib.StochasticProcess_swigregister(StochasticProcess)
class StochasticProcessVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< StochasticProcess > > class."""

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

    def iterator(self):
        r"""iterator(StochasticProcessVector self) -> SwigPyIterator"""
        return _QuantLib.StochasticProcessVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StochasticProcessVector self) -> bool"""
        return _QuantLib.StochasticProcessVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StochasticProcessVector self) -> bool"""
        return _QuantLib.StochasticProcessVector___bool__(self)

    def __len__(self):
        r"""__len__(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::size_type"""
        return _QuantLib.StochasticProcessVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j) -> StochasticProcessVector"""
        return _QuantLib.StochasticProcessVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j)
        __setslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j, StochasticProcessVector v)
        """
        return _QuantLib.StochasticProcessVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j)"""
        return _QuantLib.StochasticProcessVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i)
        __delitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.StochasticProcessVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice) -> StochasticProcessVector
        __getitem__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &
        """
        return _QuantLib.StochasticProcessVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice, StochasticProcessVector v)
        __setitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)
        """
        return _QuantLib.StochasticProcessVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type"""
        return _QuantLib.StochasticProcessVector_pop(self)

    def append(self, x):
        r"""append(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)"""
        return _QuantLib.StochasticProcessVector_append(self, x)

    def empty(self):
        r"""empty(StochasticProcessVector self) -> bool"""
        return _QuantLib.StochasticProcessVector_empty(self)

    def size(self):
        r"""size(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::size_type"""
        return _QuantLib.StochasticProcessVector_size(self)

    def swap(self, v):
        r"""swap(StochasticProcessVector self, StochasticProcessVector v)"""
        return _QuantLib.StochasticProcessVector_swap(self, v)

    def begin(self):
        r"""begin(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator"""
        return _QuantLib.StochasticProcessVector_begin(self)

    def end(self):
        r"""end(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator"""
        return _QuantLib.StochasticProcessVector_end(self)

    def rbegin(self):
        r"""rbegin(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator"""
        return _QuantLib.StochasticProcessVector_rbegin(self)

    def rend(self):
        r"""rend(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator"""
        return _QuantLib.StochasticProcessVector_rend(self)

    def clear(self):
        r"""clear(StochasticProcessVector self)"""
        return _QuantLib.StochasticProcessVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::allocator_type"""
        return _QuantLib.StochasticProcessVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StochasticProcessVector self)"""
        return _QuantLib.StochasticProcessVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator
        erase(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator first, std::vector< ext::shared_ptr< StochasticProcess > >::iterator last) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator
        """
        return _QuantLib.StochasticProcessVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StochasticProcessVector self) -> StochasticProcessVector
        __init__(StochasticProcessVector self, StochasticProcessVector other) -> StochasticProcessVector
        __init__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type size) -> StochasticProcessVector
        __init__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type size, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & value) -> StochasticProcessVector
        """
        _QuantLib.StochasticProcessVector_swiginit(self, _QuantLib.new_StochasticProcessVector(*args))

    def push_back(self, x):
        r"""push_back(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)"""
        return _QuantLib.StochasticProcessVector_push_back(self, x)

    def front(self):
        r"""front(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &"""
        return _QuantLib.StochasticProcessVector_front(self)

    def back(self):
        r"""back(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &"""
        return _QuantLib.StochasticProcessVector_back(self)

    def assign(self, n, x):
        r"""assign(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)"""
        return _QuantLib.StochasticProcessVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type new_size)
        resize(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type new_size, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)
        """
        return _QuantLib.StochasticProcessVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator
        insert(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)
        """
        return _QuantLib.StochasticProcessVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type n)"""
        return _QuantLib.StochasticProcessVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::size_type"""
        return _QuantLib.StochasticProcessVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StochasticProcessVector

# Register StochasticProcessVector in _QuantLib:
_QuantLib.StochasticProcessVector_swigregister(StochasticProcessVector)
class StochasticProcess1D(StochasticProcess):
    r"""Proxy of C++ StochasticProcess1D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def x0(self):
        r"""x0(StochasticProcess1D self) -> Real"""
        return _QuantLib.StochasticProcess1D_x0(self)

    def drift(self, t, x):
        r"""drift(StochasticProcess1D self, Time t, Real x) -> Real"""
        return _QuantLib.StochasticProcess1D_drift(self, t, x)

    def diffusion(self, t, x):
        r"""diffusion(StochasticProcess1D self, Time t, Real x) -> Real"""
        return _QuantLib.StochasticProcess1D_diffusion(self, t, x)

    def expectation(self, t0, x0, dt):
        r"""expectation(StochasticProcess1D self, Time t0, Real x0, Time dt) -> Real"""
        return _QuantLib.StochasticProcess1D_expectation(self, t0, x0, dt)

    def stdDeviation(self, t0, x0, dt):
        r"""stdDeviation(StochasticProcess1D self, Time t0, Real x0, Time dt) -> Real"""
        return _QuantLib.StochasticProcess1D_stdDeviation(self, t0, x0, dt)

    def variance(self, t0, x0, dt):
        r"""variance(StochasticProcess1D self, Time t0, Real x0, Time dt) -> Real"""
        return _QuantLib.StochasticProcess1D_variance(self, t0, x0, dt)

    def evolve(self, t0, x0, dt, dw):
        r"""evolve(StochasticProcess1D self, Time t0, Real x0, Time dt, Real dw) -> Real"""
        return _QuantLib.StochasticProcess1D_evolve(self, t0, x0, dt, dw)

    def apply(self, x0, dx):
        r"""apply(StochasticProcess1D self, Real x0, Real dx) -> Real"""
        return _QuantLib.StochasticProcess1D_apply(self, x0, dx)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess1D

# Register StochasticProcess1D in _QuantLib:
_QuantLib.StochasticProcess1D_swigregister(StochasticProcess1D)
class StochasticProcess1DVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< StochasticProcess1D > > class."""

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

    def iterator(self):
        r"""iterator(StochasticProcess1DVector self) -> SwigPyIterator"""
        return _QuantLib.StochasticProcess1DVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StochasticProcess1DVector self) -> bool"""
        return _QuantLib.StochasticProcess1DVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StochasticProcess1DVector self) -> bool"""
        return _QuantLib.StochasticProcess1DVector___bool__(self)

    def __len__(self):
        r"""__len__(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type"""
        return _QuantLib.StochasticProcess1DVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j) -> StochasticProcess1DVector"""
        return _QuantLib.StochasticProcess1DVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j)
        __setslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j, StochasticProcess1DVector v)
        """
        return _QuantLib.StochasticProcess1DVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j)"""
        return _QuantLib.StochasticProcess1DVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i)
        __delitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.StochasticProcess1DVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice) -> StochasticProcess1DVector
        __getitem__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &
        """
        return _QuantLib.StochasticProcess1DVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice, StochasticProcess1DVector v)
        __setitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)
        """
        return _QuantLib.StochasticProcess1DVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type"""
        return _QuantLib.StochasticProcess1DVector_pop(self)

    def append(self, x):
        r"""append(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)"""
        return _QuantLib.StochasticProcess1DVector_append(self, x)

    def empty(self):
        r"""empty(StochasticProcess1DVector self) -> bool"""
        return _QuantLib.StochasticProcess1DVector_empty(self)

    def size(self):
        r"""size(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type"""
        return _QuantLib.StochasticProcess1DVector_size(self)

    def swap(self, v):
        r"""swap(StochasticProcess1DVector self, StochasticProcess1DVector v)"""
        return _QuantLib.StochasticProcess1DVector_swap(self, v)

    def begin(self):
        r"""begin(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator"""
        return _QuantLib.StochasticProcess1DVector_begin(self)

    def end(self):
        r"""end(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator"""
        return _QuantLib.StochasticProcess1DVector_end(self)

    def rbegin(self):
        r"""rbegin(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator"""
        return _QuantLib.StochasticProcess1DVector_rbegin(self)

    def rend(self):
        r"""rend(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator"""
        return _QuantLib.StochasticProcess1DVector_rend(self)

    def clear(self):
        r"""clear(StochasticProcess1DVector self)"""
        return _QuantLib.StochasticProcess1DVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::allocator_type"""
        return _QuantLib.StochasticProcess1DVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StochasticProcess1DVector self)"""
        return _QuantLib.StochasticProcess1DVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator
        erase(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator first, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator last) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator
        """
        return _QuantLib.StochasticProcess1DVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StochasticProcess1DVector self) -> StochasticProcess1DVector
        __init__(StochasticProcess1DVector self, StochasticProcess1DVector other) -> StochasticProcess1DVector
        __init__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type size) -> StochasticProcess1DVector
        __init__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type size, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & value) -> StochasticProcess1DVector
        """
        _QuantLib.StochasticProcess1DVector_swiginit(self, _QuantLib.new_StochasticProcess1DVector(*args))

    def push_back(self, x):
        r"""push_back(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)"""
        return _QuantLib.StochasticProcess1DVector_push_back(self, x)

    def front(self):
        r"""front(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &"""
        return _QuantLib.StochasticProcess1DVector_front(self)

    def back(self):
        r"""back(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &"""
        return _QuantLib.StochasticProcess1DVector_back(self)

    def assign(self, n, x):
        r"""assign(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)"""
        return _QuantLib.StochasticProcess1DVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type new_size)
        resize(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type new_size, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)
        """
        return _QuantLib.StochasticProcess1DVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator
        insert(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)
        """
        return _QuantLib.StochasticProcess1DVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n)"""
        return _QuantLib.StochasticProcess1DVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type"""
        return _QuantLib.StochasticProcess1DVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess1DVector

# Register StochasticProcess1DVector in _QuantLib:
_QuantLib.StochasticProcess1DVector_swigregister(StochasticProcess1DVector)
class GeneralizedBlackScholesProcess(StochasticProcess1D):
    r"""Proxy of C++ GeneralizedBlackScholesProcess class."""

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

    def __init__(self, *args):
        r"""
        __init__(GeneralizedBlackScholesProcess self, QuoteHandle s0, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> GeneralizedBlackScholesProcess
        __init__(GeneralizedBlackScholesProcess self, QuoteHandle x0, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle blackVolTS, LocalVolTermStructureHandle localVolTS) -> GeneralizedBlackScholesProcess
        """
        _QuantLib.GeneralizedBlackScholesProcess_swiginit(self, _QuantLib.new_GeneralizedBlackScholesProcess(*args))

    def stateVariable(self):
        r"""stateVariable(GeneralizedBlackScholesProcess self) -> QuoteHandle"""
        return _QuantLib.GeneralizedBlackScholesProcess_stateVariable(self)

    def dividendYield(self):
        r"""dividendYield(GeneralizedBlackScholesProcess self) -> YieldTermStructureHandle"""
        return _QuantLib.GeneralizedBlackScholesProcess_dividendYield(self)

    def riskFreeRate(self):
        r"""riskFreeRate(GeneralizedBlackScholesProcess self) -> YieldTermStructureHandle"""
        return _QuantLib.GeneralizedBlackScholesProcess_riskFreeRate(self)

    def blackVolatility(self):
        r"""blackVolatility(GeneralizedBlackScholesProcess self) -> BlackVolTermStructureHandle"""
        return _QuantLib.GeneralizedBlackScholesProcess_blackVolatility(self)

    def localVolatility(self):
        r"""localVolatility(GeneralizedBlackScholesProcess self) -> LocalVolTermStructureHandle"""
        return _QuantLib.GeneralizedBlackScholesProcess_localVolatility(self)
    __swig_destroy__ = _QuantLib.delete_GeneralizedBlackScholesProcess

# Register GeneralizedBlackScholesProcess in _QuantLib:
_QuantLib.GeneralizedBlackScholesProcess_swigregister(GeneralizedBlackScholesProcess)
class BlackScholesProcess(GeneralizedBlackScholesProcess):
    r"""Proxy of C++ BlackScholesProcess class."""

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

    def __init__(self, s0, riskFreeTS, volTS):
        r"""__init__(BlackScholesProcess self, QuoteHandle s0, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> BlackScholesProcess"""
        _QuantLib.BlackScholesProcess_swiginit(self, _QuantLib.new_BlackScholesProcess(s0, riskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_BlackScholesProcess

# Register BlackScholesProcess in _QuantLib:
_QuantLib.BlackScholesProcess_swigregister(BlackScholesProcess)
class BlackScholesMertonProcess(GeneralizedBlackScholesProcess):
    r"""Proxy of C++ BlackScholesMertonProcess class."""

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

    def __init__(self, s0, dividendTS, riskFreeTS, volTS):
        r"""__init__(BlackScholesMertonProcess self, QuoteHandle s0, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> BlackScholesMertonProcess"""
        _QuantLib.BlackScholesMertonProcess_swiginit(self, _QuantLib.new_BlackScholesMertonProcess(s0, dividendTS, riskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_BlackScholesMertonProcess

# Register BlackScholesMertonProcess in _QuantLib:
_QuantLib.BlackScholesMertonProcess_swigregister(BlackScholesMertonProcess)
class BlackProcess(GeneralizedBlackScholesProcess):
    r"""Proxy of C++ BlackProcess class."""

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

    def __init__(self, s0, riskFreeTS, volTS):
        r"""__init__(BlackProcess self, QuoteHandle s0, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> BlackProcess"""
        _QuantLib.BlackProcess_swiginit(self, _QuantLib.new_BlackProcess(s0, riskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_BlackProcess

# Register BlackProcess in _QuantLib:
_QuantLib.BlackProcess_swigregister(BlackProcess)
class GarmanKohlagenProcess(GeneralizedBlackScholesProcess):
    r"""Proxy of C++ GarmanKohlagenProcess class."""

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

    def __init__(self, s0, foreignRiskFreeTS, domesticRiskFreeTS, volTS):
        r"""__init__(GarmanKohlagenProcess self, QuoteHandle s0, YieldTermStructureHandle foreignRiskFreeTS, YieldTermStructureHandle domesticRiskFreeTS, BlackVolTermStructureHandle volTS) -> GarmanKohlagenProcess"""
        _QuantLib.GarmanKohlagenProcess_swiginit(self, _QuantLib.new_GarmanKohlagenProcess(s0, foreignRiskFreeTS, domesticRiskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_GarmanKohlagenProcess

# Register GarmanKohlagenProcess in _QuantLib:
_QuantLib.GarmanKohlagenProcess_swigregister(GarmanKohlagenProcess)
class Merton76Process(StochasticProcess1D):
    r"""Proxy of C++ Merton76Process class."""

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

    def __init__(self, stateVariable, dividendTS, riskFreeTS, volTS, jumpIntensity, meanLogJump, jumpVolatility):
        r"""__init__(Merton76Process self, QuoteHandle stateVariable, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS, QuoteHandle jumpIntensity, QuoteHandle meanLogJump, QuoteHandle jumpVolatility) -> Merton76Process"""
        _QuantLib.Merton76Process_swiginit(self, _QuantLib.new_Merton76Process(stateVariable, dividendTS, riskFreeTS, volTS, jumpIntensity, meanLogJump, jumpVolatility))
    __swig_destroy__ = _QuantLib.delete_Merton76Process

# Register Merton76Process in _QuantLib:
_QuantLib.Merton76Process_swigregister(Merton76Process)
class StochasticProcessArray(StochasticProcess):
    r"""Proxy of C++ StochasticProcessArray class."""

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

    def __init__(self, array, correlation):
        r"""__init__(StochasticProcessArray self, StochasticProcess1DVector array, Matrix correlation) -> StochasticProcessArray"""
        _QuantLib.StochasticProcessArray_swiginit(self, _QuantLib.new_StochasticProcessArray(array, correlation))
    __swig_destroy__ = _QuantLib.delete_StochasticProcessArray

# Register StochasticProcessArray in _QuantLib:
_QuantLib.StochasticProcessArray_swigregister(StochasticProcessArray)
class GeometricBrownianMotionProcess(StochasticProcess1D):
    r"""Proxy of C++ GeometricBrownianMotionProcess class."""

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

    def __init__(self, initialValue, mu, sigma):
        r"""__init__(GeometricBrownianMotionProcess self, Real initialValue, Real mu, Real sigma) -> GeometricBrownianMotionProcess"""
        _QuantLib.GeometricBrownianMotionProcess_swiginit(self, _QuantLib.new_GeometricBrownianMotionProcess(initialValue, mu, sigma))
    __swig_destroy__ = _QuantLib.delete_GeometricBrownianMotionProcess

# Register GeometricBrownianMotionProcess in _QuantLib:
_QuantLib.GeometricBrownianMotionProcess_swigregister(GeometricBrownianMotionProcess)
class VarianceGammaProcess(StochasticProcess1D):
    r"""Proxy of C++ VarianceGammaProcess class."""

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

    def __init__(self, s0, dividendYield, riskFreeRate, sigma, nu, theta):
        r"""__init__(VarianceGammaProcess self, QuoteHandle s0, YieldTermStructureHandle dividendYield, YieldTermStructureHandle riskFreeRate, Real sigma, Real nu, Real theta) -> VarianceGammaProcess"""
        _QuantLib.VarianceGammaProcess_swiginit(self, _QuantLib.new_VarianceGammaProcess(s0, dividendYield, riskFreeRate, sigma, nu, theta))
    __swig_destroy__ = _QuantLib.delete_VarianceGammaProcess

# Register VarianceGammaProcess in _QuantLib:
_QuantLib.VarianceGammaProcess_swigregister(VarianceGammaProcess)
class HestonProcess(StochasticProcess):
    r"""Proxy of C++ HestonProcess class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PartialTruncation = _QuantLib.HestonProcess_PartialTruncation
    
    FullTruncation = _QuantLib.HestonProcess_FullTruncation
    
    Reflection = _QuantLib.HestonProcess_Reflection
    
    NonCentralChiSquareVariance = _QuantLib.HestonProcess_NonCentralChiSquareVariance
    
    QuadraticExponential = _QuantLib.HestonProcess_QuadraticExponential
    
    QuadraticExponentialMartingale = _QuantLib.HestonProcess_QuadraticExponentialMartingale
    
    BroadieKayaExactSchemeLobatto = _QuantLib.HestonProcess_BroadieKayaExactSchemeLobatto
    
    BroadieKayaExactSchemeLaguerre = _QuantLib.HestonProcess_BroadieKayaExactSchemeLaguerre
    
    BroadieKayaExactSchemeTrapezoidal = _QuantLib.HestonProcess_BroadieKayaExactSchemeTrapezoidal
    

    def __init__(self, *args):
        r"""__init__(HestonProcess self, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, QuoteHandle s0, Real v0, Real kappa, Real theta, Real sigma, Real rho, HestonProcess::Discretization d=QuadraticExponentialMartingale) -> HestonProcess"""
        _QuantLib.HestonProcess_swiginit(self, _QuantLib.new_HestonProcess(*args))

    def s0(self):
        r"""s0(HestonProcess self) -> QuoteHandle"""
        return _QuantLib.HestonProcess_s0(self)

    def dividendYield(self):
        r"""dividendYield(HestonProcess self) -> YieldTermStructureHandle"""
        return _QuantLib.HestonProcess_dividendYield(self)

    def riskFreeRate(self):
        r"""riskFreeRate(HestonProcess self) -> YieldTermStructureHandle"""
        return _QuantLib.HestonProcess_riskFreeRate(self)
    __swig_destroy__ = _QuantLib.delete_HestonProcess

# Register HestonProcess in _QuantLib:
_QuantLib.HestonProcess_swigregister(HestonProcess)
class BatesProcess(HestonProcess):
    r"""Proxy of C++ BatesProcess class."""

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

    def __init__(self, riskFreeRate, dividendYield, s0, v0, kappa, theta, sigma, rho, lambda_parameter, nu, delta):
        r"""__init__(BatesProcess self, YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, QuoteHandle s0, Real v0, Real kappa, Real theta, Real sigma, Real rho, Real lambda_parameter, Real nu, Real delta) -> BatesProcess"""
        _QuantLib.BatesProcess_swiginit(self, _QuantLib.new_BatesProcess(riskFreeRate, dividendYield, s0, v0, kappa, theta, sigma, rho, lambda_parameter, nu, delta))
    __swig_destroy__ = _QuantLib.delete_BatesProcess

# Register BatesProcess in _QuantLib:
_QuantLib.BatesProcess_swigregister(BatesProcess)
class HullWhiteProcess(StochasticProcess1D):
    r"""Proxy of C++ HullWhiteProcess class."""

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

    def __init__(self, riskFreeTS, a, sigma):
        r"""__init__(HullWhiteProcess self, YieldTermStructureHandle riskFreeTS, Real a, Real sigma) -> HullWhiteProcess"""
        _QuantLib.HullWhiteProcess_swiginit(self, _QuantLib.new_HullWhiteProcess(riskFreeTS, a, sigma))
    __swig_destroy__ = _QuantLib.delete_HullWhiteProcess

# Register HullWhiteProcess in _QuantLib:
_QuantLib.HullWhiteProcess_swigregister(HullWhiteProcess)
class HullWhiteForwardProcess(StochasticProcess1D):
    r"""Proxy of C++ HullWhiteForwardProcess class."""

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

    def __init__(self, riskFreeTS, a, sigma):
        r"""__init__(HullWhiteForwardProcess self, YieldTermStructureHandle riskFreeTS, Real a, Real sigma) -> HullWhiteForwardProcess"""
        _QuantLib.HullWhiteForwardProcess_swiginit(self, _QuantLib.new_HullWhiteForwardProcess(riskFreeTS, a, sigma))

    def alpha(self, t):
        r"""alpha(HullWhiteForwardProcess self, Time t) -> Real"""
        return _QuantLib.HullWhiteForwardProcess_alpha(self, t)

    def M_T(self, s, t, T):
        r"""M_T(HullWhiteForwardProcess self, Real s, Real t, Real T) -> Real"""
        return _QuantLib.HullWhiteForwardProcess_M_T(self, s, t, T)

    def B(self, t, T):
        r"""B(HullWhiteForwardProcess self, Time t, Time T) -> Real"""
        return _QuantLib.HullWhiteForwardProcess_B(self, t, T)

    def setForwardMeasureTime(self, t):
        r"""setForwardMeasureTime(HullWhiteForwardProcess self, Time t)"""
        return _QuantLib.HullWhiteForwardProcess_setForwardMeasureTime(self, t)
    __swig_destroy__ = _QuantLib.delete_HullWhiteForwardProcess

# Register HullWhiteForwardProcess in _QuantLib:
_QuantLib.HullWhiteForwardProcess_swigregister(HullWhiteForwardProcess)
class G2Process(StochasticProcess):
    r"""Proxy of C++ G2Process class."""

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

    def __init__(self, a, sigma, b, eta, rho):
        r"""__init__(G2Process self, Real a, Real sigma, Real b, Real eta, Real rho) -> G2Process"""
        _QuantLib.G2Process_swiginit(self, _QuantLib.new_G2Process(a, sigma, b, eta, rho))
    __swig_destroy__ = _QuantLib.delete_G2Process

# Register G2Process in _QuantLib:
_QuantLib.G2Process_swigregister(G2Process)
class G2ForwardProcess(StochasticProcess):
    r"""Proxy of C++ G2ForwardProcess class."""

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

    def __init__(self, a, sigma, b, eta, rho):
        r"""__init__(G2ForwardProcess self, Real a, Real sigma, Real b, Real eta, Real rho) -> G2ForwardProcess"""
        _QuantLib.G2ForwardProcess_swiginit(self, _QuantLib.new_G2ForwardProcess(a, sigma, b, eta, rho))

    def setForwardMeasureTime(self, t):
        r"""setForwardMeasureTime(G2ForwardProcess self, Time t)"""
        return _QuantLib.G2ForwardProcess_setForwardMeasureTime(self, t)
    __swig_destroy__ = _QuantLib.delete_G2ForwardProcess

# Register G2ForwardProcess in _QuantLib:
_QuantLib.G2ForwardProcess_swigregister(G2ForwardProcess)
class GsrProcess(StochasticProcess1D):
    r"""Proxy of C++ GsrProcess class."""

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

    def __init__(self, times, vols, reversions, T=60.0):
        r"""__init__(GsrProcess self, Array times, Array vols, Array reversions, Real const T=60.0) -> GsrProcess"""
        _QuantLib.GsrProcess_swiginit(self, _QuantLib.new_GsrProcess(times, vols, reversions, T))

    def sigma(self, t):
        r"""sigma(GsrProcess self, Time t) -> Real"""
        return _QuantLib.GsrProcess_sigma(self, t)

    def reversion(self, t):
        r"""reversion(GsrProcess self, Time t) -> Real"""
        return _QuantLib.GsrProcess_reversion(self, t)

    def y(self, t):
        r"""y(GsrProcess self, Time t) -> Real"""
        return _QuantLib.GsrProcess_y(self, t)

    def G(self, t, T, x):
        r"""G(GsrProcess self, Time t, Time T, Real x) -> Real"""
        return _QuantLib.GsrProcess_G(self, t, T, x)

    def setForwardMeasureTime(self, t):
        r"""setForwardMeasureTime(GsrProcess self, Time t)"""
        return _QuantLib.GsrProcess_setForwardMeasureTime(self, t)
    __swig_destroy__ = _QuantLib.delete_GsrProcess

# Register GsrProcess in _QuantLib:
_QuantLib.GsrProcess_swigregister(GsrProcess)

def as_gsr_process(proc):
    r"""as_gsr_process(ext::shared_ptr< StochasticProcess > const & proc) -> ext::shared_ptr< GsrProcess > const"""
    return _QuantLib.as_gsr_process(proc)
class OrnsteinUhlenbeckProcess(StochasticProcess1D):
    r"""Proxy of C++ OrnsteinUhlenbeckProcess class."""

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

    def __init__(self, speed, vol, x0=0.0, level=0.0):
        r"""__init__(OrnsteinUhlenbeckProcess self, Real speed, Volatility vol, Real x0=0.0, Real level=0.0) -> OrnsteinUhlenbeckProcess"""
        _QuantLib.OrnsteinUhlenbeckProcess_swiginit(self, _QuantLib.new_OrnsteinUhlenbeckProcess(speed, vol, x0, level))

    def speed(self):
        r"""speed(OrnsteinUhlenbeckProcess self) -> Real"""
        return _QuantLib.OrnsteinUhlenbeckProcess_speed(self)

    def volatility(self):
        r"""volatility(OrnsteinUhlenbeckProcess self) -> Real"""
        return _QuantLib.OrnsteinUhlenbeckProcess_volatility(self)

    def level(self):
        r"""level(OrnsteinUhlenbeckProcess self) -> Real"""
        return _QuantLib.OrnsteinUhlenbeckProcess_level(self)
    __swig_destroy__ = _QuantLib.delete_OrnsteinUhlenbeckProcess

# Register OrnsteinUhlenbeckProcess in _QuantLib:
_QuantLib.OrnsteinUhlenbeckProcess_swigregister(OrnsteinUhlenbeckProcess)
class ExtendedOrnsteinUhlenbeckProcess(StochasticProcess1D):
    r"""Proxy of C++ ExtendedOrnsteinUhlenbeckProcess class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MidPoint = _QuantLib.ExtendedOrnsteinUhlenbeckProcess_MidPoint
    
    Trapezodial = _QuantLib.ExtendedOrnsteinUhlenbeckProcess_Trapezodial
    
    GaussLobatto = _QuantLib.ExtendedOrnsteinUhlenbeckProcess_GaussLobatto
    

    def __init__(self, *args):
        r"""
        __init__(ExtendedOrnsteinUhlenbeckProcess self, Real speed, Volatility sigma, Real x0, ext::function< Real (Real) > const & b, ExtendedOrnsteinUhlenbeckProcess::Discretization discretization=MidPoint, Real intEps=1e-4) -> ExtendedOrnsteinUhlenbeckProcess
        __init__(ExtendedOrnsteinUhlenbeckProcess self, Real speed, Volatility sigma, Real x0, PyObject * function, Real intEps=1e-4) -> ExtendedOrnsteinUhlenbeckProcess
        """
        _QuantLib.ExtendedOrnsteinUhlenbeckProcess_swiginit(self, _QuantLib.new_ExtendedOrnsteinUhlenbeckProcess(*args))
    __swig_destroy__ = _QuantLib.delete_ExtendedOrnsteinUhlenbeckProcess

# Register ExtendedOrnsteinUhlenbeckProcess in _QuantLib:
_QuantLib.ExtendedOrnsteinUhlenbeckProcess_swigregister(ExtendedOrnsteinUhlenbeckProcess)
class ExtOUWithJumpsProcess(StochasticProcess):
    r"""Proxy of C++ ExtOUWithJumpsProcess class."""

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

    def __init__(self, process, Y0, beta, jumpIntensity, eta):
        r"""__init__(ExtOUWithJumpsProcess self, ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const & process, Real Y0, Real beta, Real jumpIntensity, Real eta) -> ExtOUWithJumpsProcess"""
        _QuantLib.ExtOUWithJumpsProcess_swiginit(self, _QuantLib.new_ExtOUWithJumpsProcess(process, Y0, beta, jumpIntensity, eta))
    __swig_destroy__ = _QuantLib.delete_ExtOUWithJumpsProcess

# Register ExtOUWithJumpsProcess in _QuantLib:
_QuantLib.ExtOUWithJumpsProcess_swigregister(ExtOUWithJumpsProcess)
class KlugeExtOUProcess(StochasticProcess):
    r"""Proxy of C++ KlugeExtOUProcess class."""

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

    def __init__(self, rho, kluge, extOU):
        r"""__init__(KlugeExtOUProcess self, Real rho, ext::shared_ptr< ExtOUWithJumpsProcess > const & kluge, ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const & extOU) -> KlugeExtOUProcess"""
        _QuantLib.KlugeExtOUProcess_swiginit(self, _QuantLib.new_KlugeExtOUProcess(rho, kluge, extOU))
    __swig_destroy__ = _QuantLib.delete_KlugeExtOUProcess

# Register KlugeExtOUProcess in _QuantLib:
_QuantLib.KlugeExtOUProcess_swigregister(KlugeExtOUProcess)
class GJRGARCHProcess(StochasticProcess):
    r"""Proxy of C++ GJRGARCHProcess class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PartialTruncation = _QuantLib.GJRGARCHProcess_PartialTruncation
    
    FullTruncation = _QuantLib.GJRGARCHProcess_FullTruncation
    
    Reflection = _QuantLib.GJRGARCHProcess_Reflection
    

    def __init__(self, *args):
        r"""__init__(GJRGARCHProcess self, YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, QuoteHandle s0, Real v0, Real omega, Real alpha, Real beta, Real gamma, Real lambda_parameter, Real daysPerYear=252.0, GJRGARCHProcess::Discretization d=FullTruncation) -> GJRGARCHProcess"""
        _QuantLib.GJRGARCHProcess_swiginit(self, _QuantLib.new_GJRGARCHProcess(*args))

    def s0(self):
        r"""s0(GJRGARCHProcess self) -> QuoteHandle"""
        return _QuantLib.GJRGARCHProcess_s0(self)

    def dividendYield(self):
        r"""dividendYield(GJRGARCHProcess self) -> YieldTermStructureHandle"""
        return _QuantLib.GJRGARCHProcess_dividendYield(self)

    def riskFreeRate(self):
        r"""riskFreeRate(GJRGARCHProcess self) -> YieldTermStructureHandle"""
        return _QuantLib.GJRGARCHProcess_riskFreeRate(self)
    __swig_destroy__ = _QuantLib.delete_GJRGARCHProcess

# Register GJRGARCHProcess in _QuantLib:
_QuantLib.GJRGARCHProcess_swigregister(GJRGARCHProcess)
class PricingEngine(Observable):
    r"""Proxy of C++ PricingEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register PricingEngine in _QuantLib:
_QuantLib.PricingEngine_swigregister(PricingEngine)
class Instrument(Observable):
    r"""Proxy of C++ Instrument class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def NPV(self):
        r"""NPV(Instrument self) -> Real"""
        return _QuantLib.Instrument_NPV(self)

    def errorEstimate(self):
        r"""errorEstimate(Instrument self) -> Real"""
        return _QuantLib.Instrument_errorEstimate(self)

    def isExpired(self):
        r"""isExpired(Instrument self) -> bool"""
        return _QuantLib.Instrument_isExpired(self)

    def setPricingEngine(self, arg2):
        r"""setPricingEngine(Instrument self, ext::shared_ptr< PricingEngine > const & arg2)"""
        return _QuantLib.Instrument_setPricingEngine(self, arg2)

    def recalculate(self):
        r"""recalculate(Instrument self)"""
        return _QuantLib.Instrument_recalculate(self)

    def freeze(self):
        r"""freeze(Instrument self)"""
        return _QuantLib.Instrument_freeze(self)

    def unfreeze(self):
        r"""unfreeze(Instrument self)"""
        return _QuantLib.Instrument_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_Instrument

# Register Instrument in _QuantLib:
_QuantLib.Instrument_swigregister(Instrument)
class InstrumentVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< Instrument > > class."""

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

    def iterator(self):
        r"""iterator(InstrumentVector self) -> SwigPyIterator"""
        return _QuantLib.InstrumentVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(InstrumentVector self) -> bool"""
        return _QuantLib.InstrumentVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(InstrumentVector self) -> bool"""
        return _QuantLib.InstrumentVector___bool__(self)

    def __len__(self):
        r"""__len__(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::size_type"""
        return _QuantLib.InstrumentVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j) -> InstrumentVector"""
        return _QuantLib.InstrumentVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j)
        __setslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j, InstrumentVector v)
        """
        return _QuantLib.InstrumentVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j)"""
        return _QuantLib.InstrumentVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i)
        __delitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.InstrumentVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice) -> InstrumentVector
        __getitem__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i) -> std::vector< ext::shared_ptr< Instrument > >::value_type const &
        """
        return _QuantLib.InstrumentVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice, InstrumentVector v)
        __setitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)
        """
        return _QuantLib.InstrumentVector___setitem__(self, *args)

    def pop(self):
        r"""pop(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::value_type"""
        return _QuantLib.InstrumentVector_pop(self)

    def append(self, x):
        r"""append(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)"""
        return _QuantLib.InstrumentVector_append(self, x)

    def empty(self):
        r"""empty(InstrumentVector self) -> bool"""
        return _QuantLib.InstrumentVector_empty(self)

    def size(self):
        r"""size(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::size_type"""
        return _QuantLib.InstrumentVector_size(self)

    def swap(self, v):
        r"""swap(InstrumentVector self, InstrumentVector v)"""
        return _QuantLib.InstrumentVector_swap(self, v)

    def begin(self):
        r"""begin(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::iterator"""
        return _QuantLib.InstrumentVector_begin(self)

    def end(self):
        r"""end(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::iterator"""
        return _QuantLib.InstrumentVector_end(self)

    def rbegin(self):
        r"""rbegin(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::reverse_iterator"""
        return _QuantLib.InstrumentVector_rbegin(self)

    def rend(self):
        r"""rend(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::reverse_iterator"""
        return _QuantLib.InstrumentVector_rend(self)

    def clear(self):
        r"""clear(InstrumentVector self)"""
        return _QuantLib.InstrumentVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::allocator_type"""
        return _QuantLib.InstrumentVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(InstrumentVector self)"""
        return _QuantLib.InstrumentVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator pos) -> std::vector< ext::shared_ptr< Instrument > >::iterator
        erase(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator first, std::vector< ext::shared_ptr< Instrument > >::iterator last) -> std::vector< ext::shared_ptr< Instrument > >::iterator
        """
        return _QuantLib.InstrumentVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(InstrumentVector self) -> InstrumentVector
        __init__(InstrumentVector self, InstrumentVector other) -> InstrumentVector
        __init__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type size) -> InstrumentVector
        __init__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type size, std::vector< ext::shared_ptr< Instrument > >::value_type const & value) -> InstrumentVector
        """
        _QuantLib.InstrumentVector_swiginit(self, _QuantLib.new_InstrumentVector(*args))

    def push_back(self, x):
        r"""push_back(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)"""
        return _QuantLib.InstrumentVector_push_back(self, x)

    def front(self):
        r"""front(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::value_type const &"""
        return _QuantLib.InstrumentVector_front(self)

    def back(self):
        r"""back(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::value_type const &"""
        return _QuantLib.InstrumentVector_back(self)

    def assign(self, n, x):
        r"""assign(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type n, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)"""
        return _QuantLib.InstrumentVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type new_size)
        resize(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type new_size, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)
        """
        return _QuantLib.InstrumentVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator pos, std::vector< ext::shared_ptr< Instrument > >::value_type const & x) -> std::vector< ext::shared_ptr< Instrument > >::iterator
        insert(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator pos, std::vector< ext::shared_ptr< Instrument > >::size_type n, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)
        """
        return _QuantLib.InstrumentVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type n)"""
        return _QuantLib.InstrumentVector_reserve(self, n)

    def capacity(self):
        r"""capacity(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::size_type"""
        return _QuantLib.InstrumentVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_InstrumentVector

# Register InstrumentVector in _QuantLib:
_QuantLib.InstrumentVector_swigregister(InstrumentVector)
class Stock(Instrument):
    r"""Proxy of C++ Stock class."""

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

    def __init__(self, quote):
        r"""__init__(Stock self, QuoteHandle quote) -> Stock"""
        _QuantLib.Stock_swiginit(self, _QuantLib.new_Stock(quote))
    __swig_destroy__ = _QuantLib.delete_Stock

# Register Stock in _QuantLib:
_QuantLib.Stock_swigregister(Stock)
class CompositeInstrument(Instrument):
    r"""Proxy of C++ CompositeInstrument class."""

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

    def __init__(self):
        r"""__init__(CompositeInstrument self) -> CompositeInstrument"""
        _QuantLib.CompositeInstrument_swiginit(self, _QuantLib.new_CompositeInstrument())

    def add(self, instrument, multiplier=1.0):
        r"""add(CompositeInstrument self, ext::shared_ptr< Instrument > const & instrument, Real multiplier=1.0)"""
        return _QuantLib.CompositeInstrument_add(self, instrument, multiplier)

    def subtract(self, instrument, multiplier=1.0):
        r"""subtract(CompositeInstrument self, ext::shared_ptr< Instrument > const & instrument, Real multiplier=1.0)"""
        return _QuantLib.CompositeInstrument_subtract(self, instrument, multiplier)
    __swig_destroy__ = _QuantLib.delete_CompositeInstrument

# Register CompositeInstrument in _QuantLib:
_QuantLib.CompositeInstrument_swigregister(CompositeInstrument)
class DateGeneration(object):
    r"""Proxy of C++ DateGeneration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Backward = _QuantLib.DateGeneration_Backward
    
    Forward = _QuantLib.DateGeneration_Forward
    
    Zero = _QuantLib.DateGeneration_Zero
    
    ThirdWednesday = _QuantLib.DateGeneration_ThirdWednesday
    
    ThirdWednesdayInclusive = _QuantLib.DateGeneration_ThirdWednesdayInclusive
    
    Twentieth = _QuantLib.DateGeneration_Twentieth
    
    TwentiethIMM = _QuantLib.DateGeneration_TwentiethIMM
    
    OldCDS = _QuantLib.DateGeneration_OldCDS
    
    CDS = _QuantLib.DateGeneration_CDS
    
    CDS2015 = _QuantLib.DateGeneration_CDS2015
    

    def __init__(self):
        r"""__init__(DateGeneration self) -> DateGeneration"""
        _QuantLib.DateGeneration_swiginit(self, _QuantLib.new_DateGeneration())
    __swig_destroy__ = _QuantLib.delete_DateGeneration

# Register DateGeneration in _QuantLib:
_QuantLib.DateGeneration_swigregister(DateGeneration)
class Schedule(object):
    r"""Proxy of C++ Schedule class."""

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

    def __init__(self, *args):
        r"""
        __init__(Schedule self, DateVector arg2, Calendar calendar=NullCalendar(), BusinessDayConvention const convention=Unadjusted, boost::optional< BusinessDayConvention > terminationDateConvention=boost::none, boost::optional< Period > const tenor=boost::none, boost::optional< DateGeneration::Rule > rule=boost::none, boost::optional< bool > endOfMonth=boost::none, BoolVector isRegular=std::vector< bool >(0)) -> Schedule
        __init__(Schedule self, Date effectiveDate, Date terminationDate, Period tenor, Calendar calendar, BusinessDayConvention convention, BusinessDayConvention terminationDateConvention, DateGeneration::Rule rule, bool endOfMonth, Date firstDate=Date(), Date nextToLastDate=Date()) -> Schedule
        __init__(Schedule self) -> Schedule
        """
        _QuantLib.Schedule_swiginit(self, _QuantLib.new_Schedule(*args))

    def __len__(self):
        r"""__len__(Schedule self) -> Size"""
        return _QuantLib.Schedule___len__(self)

    def previousDate(self, refDate):
        r"""previousDate(Schedule self, Date refDate) -> Date"""
        return _QuantLib.Schedule_previousDate(self, refDate)

    def nextDate(self, refDate):
        r"""nextDate(Schedule self, Date refDate) -> Date"""
        return _QuantLib.Schedule_nextDate(self, refDate)

    def dates(self):
        r"""dates(Schedule self) -> DateVector"""
        return _QuantLib.Schedule_dates(self)

    def hasIsRegular(self):
        r"""hasIsRegular(Schedule self) -> bool"""
        return _QuantLib.Schedule_hasIsRegular(self)

    def isRegular(self, *args):
        r"""
        isRegular(Schedule self, Size i) -> bool
        isRegular(Schedule self) -> BoolVector
        """
        return _QuantLib.Schedule_isRegular(self, *args)

    def calendar(self):
        r"""calendar(Schedule self) -> Calendar"""
        return _QuantLib.Schedule_calendar(self)

    def startDate(self):
        r"""startDate(Schedule self) -> Date"""
        return _QuantLib.Schedule_startDate(self)

    def endDate(self):
        r"""endDate(Schedule self) -> Date"""
        return _QuantLib.Schedule_endDate(self)

    def hasTenor(self):
        r"""hasTenor(Schedule self) -> bool"""
        return _QuantLib.Schedule_hasTenor(self)

    def tenor(self):
        r"""tenor(Schedule self) -> Period"""
        return _QuantLib.Schedule_tenor(self)

    def businessDayConvention(self):
        r"""businessDayConvention(Schedule self) -> BusinessDayConvention"""
        return _QuantLib.Schedule_businessDayConvention(self)

    def hasTerminationDateBusinessDayConvention(self):
        r"""hasTerminationDateBusinessDayConvention(Schedule self) -> bool"""
        return _QuantLib.Schedule_hasTerminationDateBusinessDayConvention(self)

    def terminationDateBusinessDayConvention(self):
        r"""terminationDateBusinessDayConvention(Schedule self) -> BusinessDayConvention"""
        return _QuantLib.Schedule_terminationDateBusinessDayConvention(self)

    def hasRule(self):
        r"""hasRule(Schedule self) -> bool"""
        return _QuantLib.Schedule_hasRule(self)

    def rule(self):
        r"""rule(Schedule self) -> DateGeneration::Rule"""
        return _QuantLib.Schedule_rule(self)

    def hasEndOfMonth(self):
        r"""hasEndOfMonth(Schedule self) -> bool"""
        return _QuantLib.Schedule_hasEndOfMonth(self)

    def endOfMonth(self):
        r"""endOfMonth(Schedule self) -> bool"""
        return _QuantLib.Schedule_endOfMonth(self)

    def after(self, truncationDate):
        r"""after(Schedule self, Date truncationDate) -> Schedule"""
        return _QuantLib.Schedule_after(self, truncationDate)

    def until(self, truncationDate):
        r"""until(Schedule self, Date truncationDate) -> Schedule"""
        return _QuantLib.Schedule_until(self, truncationDate)

    def __getitem__(self, i):
        r"""__getitem__(Schedule self, Integer i) -> Date"""
        return _QuantLib.Schedule___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_Schedule

# Register Schedule in _QuantLib:
_QuantLib.Schedule_swigregister(Schedule)
class _MakeSchedule(object):
    r"""Proxy of C++ MakeSchedule class."""

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

    def __init__(self):
        r"""__init__(_MakeSchedule self) -> _MakeSchedule"""
        _QuantLib._MakeSchedule_swiginit(self, _QuantLib.new__MakeSchedule())

    def fromDate(self, effectiveDate):
        r"""fromDate(_MakeSchedule self, Date effectiveDate) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_fromDate(self, effectiveDate)

    def to(self, terminationDate):
        r"""to(_MakeSchedule self, Date terminationDate) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_to(self, terminationDate)

    def withTenor(self, arg2):
        r"""withTenor(_MakeSchedule self, Period arg2) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withTenor(self, arg2)

    def withFrequency(self, arg2):
        r"""withFrequency(_MakeSchedule self, Frequency arg2) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withFrequency(self, arg2)

    def withCalendar(self, arg2):
        r"""withCalendar(_MakeSchedule self, Calendar arg2) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withCalendar(self, arg2)

    def withConvention(self, arg2):
        r"""withConvention(_MakeSchedule self, BusinessDayConvention arg2) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withConvention(self, arg2)

    def withTerminationDateConvention(self, arg2):
        r"""withTerminationDateConvention(_MakeSchedule self, BusinessDayConvention arg2) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withTerminationDateConvention(self, arg2)

    def withRule(self, arg2):
        r"""withRule(_MakeSchedule self, DateGeneration::Rule arg2) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withRule(self, arg2)

    def forwards(self):
        r"""forwards(_MakeSchedule self) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_forwards(self)

    def backwards(self):
        r"""backwards(_MakeSchedule self) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_backwards(self)

    def endOfMonth(self, flag=True):
        r"""endOfMonth(_MakeSchedule self, bool flag=True) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_endOfMonth(self, flag)

    def withFirstDate(self, d):
        r"""withFirstDate(_MakeSchedule self, Date d) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withFirstDate(self, d)

    def withNextToLastDate(self, d):
        r"""withNextToLastDate(_MakeSchedule self, Date d) -> _MakeSchedule"""
        return _QuantLib._MakeSchedule_withNextToLastDate(self, d)

    def schedule(self):
        r"""schedule(_MakeSchedule self) -> Schedule"""
        return _QuantLib._MakeSchedule_schedule(self)
    __swig_destroy__ = _QuantLib.delete__MakeSchedule

# Register _MakeSchedule in _QuantLib:
_QuantLib._MakeSchedule_swigregister(_MakeSchedule)

def MakeSchedule(effectiveDate=None,terminationDate=None,tenor=None,
    frequency=None,calendar=None,convention=None,terminalDateConvention=None,
    rule=None,forwards=False,backwards=False,
    endOfMonth=None,firstDate=None,nextToLastDate=None):
    ms = _MakeSchedule()
    if effectiveDate is not None:
        ms.fromDate(effectiveDate)
    if terminationDate is not None:
        ms.to(terminationDate)
    if tenor is not None:
        ms.withTenor(tenor)
    if frequency is not None:
        ms.withFrequency(frequency)
    if calendar is not None:
        ms.withCalendar(calendar)
    if convention is not None:
        ms.withConvention(convention)
    if terminalDateConvention is not None:
        ms.withTerminationDateConvention(terminalDateConvention)
    if rule is not None:
        ms.withRule(rule)
    if forwards:
        ms.forwards()
    if backwards:
        ms.backwards()
    if endOfMonth is not None:
        ms.endOfMonth(endOfMonth)
    if firstDate is not None:
        ms.withFirstDate(firstDate)
    if nextToLastDate is not None:
        ms.withNextToLastDate(nextToLastDate)
    return ms.schedule()

class CashFlow(Observable):
    r"""Proxy of C++ CashFlow class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def amount(self):
        r"""amount(CashFlow self) -> Real"""
        return _QuantLib.CashFlow_amount(self)

    def date(self):
        r"""date(CashFlow self) -> Date"""
        return _QuantLib.CashFlow_date(self)

    def hasOccurred(self, *args):
        r"""hasOccurred(CashFlow self, Date refDate=Date()) -> bool"""
        return _QuantLib.CashFlow_hasOccurred(self, *args)
    __swig_destroy__ = _QuantLib.delete_CashFlow

# Register CashFlow in _QuantLib:
_QuantLib.CashFlow_swigregister(CashFlow)
class Leg(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< CashFlow > > class."""

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

    def iterator(self):
        r"""iterator(Leg self) -> SwigPyIterator"""
        return _QuantLib.Leg_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Leg self) -> bool"""
        return _QuantLib.Leg___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Leg self) -> bool"""
        return _QuantLib.Leg___bool__(self)

    def __len__(self):
        r"""__len__(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::size_type"""
        return _QuantLib.Leg___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j) -> Leg"""
        return _QuantLib.Leg___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j)
        __setslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j, Leg v)
        """
        return _QuantLib.Leg___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j)"""
        return _QuantLib.Leg___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i)
        __delitem__(Leg self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.Leg___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Leg self, SWIGPY_SLICEOBJECT * slice) -> Leg
        __getitem__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i) -> std::vector< ext::shared_ptr< CashFlow > >::value_type const &
        """
        return _QuantLib.Leg___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Leg self, SWIGPY_SLICEOBJECT * slice, Leg v)
        __setitem__(Leg self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)
        """
        return _QuantLib.Leg___setitem__(self, *args)

    def pop(self):
        r"""pop(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::value_type"""
        return _QuantLib.Leg_pop(self)

    def append(self, x):
        r"""append(Leg self, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)"""
        return _QuantLib.Leg_append(self, x)

    def empty(self):
        r"""empty(Leg self) -> bool"""
        return _QuantLib.Leg_empty(self)

    def size(self):
        r"""size(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::size_type"""
        return _QuantLib.Leg_size(self)

    def swap(self, v):
        r"""swap(Leg self, Leg v)"""
        return _QuantLib.Leg_swap(self, v)

    def begin(self):
        r"""begin(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::iterator"""
        return _QuantLib.Leg_begin(self)

    def end(self):
        r"""end(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::iterator"""
        return _QuantLib.Leg_end(self)

    def rbegin(self):
        r"""rbegin(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator"""
        return _QuantLib.Leg_rbegin(self)

    def rend(self):
        r"""rend(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator"""
        return _QuantLib.Leg_rend(self)

    def clear(self):
        r"""clear(Leg self)"""
        return _QuantLib.Leg_clear(self)

    def get_allocator(self):
        r"""get_allocator(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::allocator_type"""
        return _QuantLib.Leg_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Leg self)"""
        return _QuantLib.Leg_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator pos) -> std::vector< ext::shared_ptr< CashFlow > >::iterator
        erase(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator first, std::vector< ext::shared_ptr< CashFlow > >::iterator last) -> std::vector< ext::shared_ptr< CashFlow > >::iterator
        """
        return _QuantLib.Leg_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Leg self) -> Leg
        __init__(Leg self, Leg other) -> Leg
        __init__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type size) -> Leg
        __init__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type size, std::vector< ext::shared_ptr< CashFlow > >::value_type const & value) -> Leg
        """
        _QuantLib.Leg_swiginit(self, _QuantLib.new_Leg(*args))

    def push_back(self, x):
        r"""push_back(Leg self, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)"""
        return _QuantLib.Leg_push_back(self, x)

    def front(self):
        r"""front(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::value_type const &"""
        return _QuantLib.Leg_front(self)

    def back(self):
        r"""back(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::value_type const &"""
        return _QuantLib.Leg_back(self)

    def assign(self, n, x):
        r"""assign(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type n, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)"""
        return _QuantLib.Leg_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type new_size)
        resize(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type new_size, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)
        """
        return _QuantLib.Leg_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator pos, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x) -> std::vector< ext::shared_ptr< CashFlow > >::iterator
        insert(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator pos, std::vector< ext::shared_ptr< CashFlow > >::size_type n, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)
        """
        return _QuantLib.Leg_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type n)"""
        return _QuantLib.Leg_reserve(self, n)

    def capacity(self):
        r"""capacity(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::size_type"""
        return _QuantLib.Leg_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Leg

# Register Leg in _QuantLib:
_QuantLib.Leg_swigregister(Leg)
class LegVector(object):
    r"""Proxy of C++ std::vector< Leg > class."""

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

    def iterator(self):
        r"""iterator(LegVector self) -> SwigPyIterator"""
        return _QuantLib.LegVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(LegVector self) -> bool"""
        return _QuantLib.LegVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(LegVector self) -> bool"""
        return _QuantLib.LegVector___bool__(self)

    def __len__(self):
        r"""__len__(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type"""
        return _QuantLib.LegVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j) -> LegVector"""
        return _QuantLib.LegVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j)
        __setslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j, LegVector v)
        """
        return _QuantLib.LegVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j)"""
        return _QuantLib.LegVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i)
        __delitem__(LegVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.LegVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(LegVector self, SWIGPY_SLICEOBJECT * slice) -> LegVector
        __getitem__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i) -> Leg
        """
        return _QuantLib.LegVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(LegVector self, SWIGPY_SLICEOBJECT * slice, LegVector v)
        __setitem__(LegVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, Leg x)
        """
        return _QuantLib.LegVector___setitem__(self, *args)

    def pop(self):
        r"""pop(LegVector self) -> Leg"""
        return _QuantLib.LegVector_pop(self)

    def append(self, x):
        r"""append(LegVector self, Leg x)"""
        return _QuantLib.LegVector_append(self, x)

    def empty(self):
        r"""empty(LegVector self) -> bool"""
        return _QuantLib.LegVector_empty(self)

    def size(self):
        r"""size(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type"""
        return _QuantLib.LegVector_size(self)

    def swap(self, v):
        r"""swap(LegVector self, LegVector v)"""
        return _QuantLib.LegVector_swap(self, v)

    def begin(self):
        r"""begin(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator"""
        return _QuantLib.LegVector_begin(self)

    def end(self):
        r"""end(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator"""
        return _QuantLib.LegVector_end(self)

    def rbegin(self):
        r"""rbegin(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator"""
        return _QuantLib.LegVector_rbegin(self)

    def rend(self):
        r"""rend(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator"""
        return _QuantLib.LegVector_rend(self)

    def clear(self):
        r"""clear(LegVector self)"""
        return _QuantLib.LegVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::allocator_type"""
        return _QuantLib.LegVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(LegVector self)"""
        return _QuantLib.LegVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator
        erase(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator first, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator last) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator
        """
        return _QuantLib.LegVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(LegVector self) -> LegVector
        __init__(LegVector self, LegVector other) -> LegVector
        __init__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type size) -> LegVector
        __init__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type size, Leg value) -> LegVector
        """
        _QuantLib.LegVector_swiginit(self, _QuantLib.new_LegVector(*args))

    def push_back(self, x):
        r"""push_back(LegVector self, Leg x)"""
        return _QuantLib.LegVector_push_back(self, x)

    def front(self):
        r"""front(LegVector self) -> Leg"""
        return _QuantLib.LegVector_front(self)

    def back(self):
        r"""back(LegVector self) -> Leg"""
        return _QuantLib.LegVector_back(self)

    def assign(self, n, x):
        r"""assign(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n, Leg x)"""
        return _QuantLib.LegVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type new_size)
        resize(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type new_size, Leg x)
        """
        return _QuantLib.LegVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos, Leg x) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator
        insert(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n, Leg x)
        """
        return _QuantLib.LegVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n)"""
        return _QuantLib.LegVector_reserve(self, n)

    def capacity(self):
        r"""capacity(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type"""
        return _QuantLib.LegVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_LegVector

# Register LegVector in _QuantLib:
_QuantLib.LegVector_swigregister(LegVector)
class SimpleCashFlow(CashFlow):
    r"""Proxy of C++ SimpleCashFlow class."""

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

    def __init__(self, amount, date):
        r"""__init__(SimpleCashFlow self, Real amount, Date date) -> SimpleCashFlow"""
        _QuantLib.SimpleCashFlow_swiginit(self, _QuantLib.new_SimpleCashFlow(amount, date))
    __swig_destroy__ = _QuantLib.delete_SimpleCashFlow

# Register SimpleCashFlow in _QuantLib:
_QuantLib.SimpleCashFlow_swigregister(SimpleCashFlow)
class Redemption(CashFlow):
    r"""Proxy of C++ Redemption class."""

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

    def __init__(self, amount, date):
        r"""__init__(Redemption self, Real amount, Date date) -> Redemption"""
        _QuantLib.Redemption_swiginit(self, _QuantLib.new_Redemption(amount, date))
    __swig_destroy__ = _QuantLib.delete_Redemption

# Register Redemption in _QuantLib:
_QuantLib.Redemption_swigregister(Redemption)
class AmortizingPayment(CashFlow):
    r"""Proxy of C++ AmortizingPayment class."""

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

    def __init__(self, amount, date):
        r"""__init__(AmortizingPayment self, Real amount, Date date) -> AmortizingPayment"""
        _QuantLib.AmortizingPayment_swiginit(self, _QuantLib.new_AmortizingPayment(amount, date))
    __swig_destroy__ = _QuantLib.delete_AmortizingPayment

# Register AmortizingPayment in _QuantLib:
_QuantLib.AmortizingPayment_swigregister(AmortizingPayment)
class IndexedCashFlow(CashFlow):
    r"""Proxy of C++ IndexedCashFlow class."""

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

    def __init__(self, notional, index, baseDate, fixingDate, paymentDate, growthOnly=False):
        r"""__init__(IndexedCashFlow self, Real notional, ext::shared_ptr< Index > const & index, Date baseDate, Date fixingDate, Date paymentDate, bool growthOnly=False) -> IndexedCashFlow"""
        _QuantLib.IndexedCashFlow_swiginit(self, _QuantLib.new_IndexedCashFlow(notional, index, baseDate, fixingDate, paymentDate, growthOnly))

    def notional(self):
        r"""notional(IndexedCashFlow self) -> Real"""
        return _QuantLib.IndexedCashFlow_notional(self)

    def baseDate(self):
        r"""baseDate(IndexedCashFlow self) -> Date"""
        return _QuantLib.IndexedCashFlow_baseDate(self)

    def fixingDate(self):
        r"""fixingDate(IndexedCashFlow self) -> Date"""
        return _QuantLib.IndexedCashFlow_fixingDate(self)

    def baseFixing(self):
        r"""baseFixing(IndexedCashFlow self) -> Real"""
        return _QuantLib.IndexedCashFlow_baseFixing(self)

    def indexFixing(self):
        r"""indexFixing(IndexedCashFlow self) -> Real"""
        return _QuantLib.IndexedCashFlow_indexFixing(self)

    def index(self):
        r"""index(IndexedCashFlow self) -> ext::shared_ptr< Index >"""
        return _QuantLib.IndexedCashFlow_index(self)

    def growthOnly(self):
        r"""growthOnly(IndexedCashFlow self) -> bool"""
        return _QuantLib.IndexedCashFlow_growthOnly(self)
    __swig_destroy__ = _QuantLib.delete_IndexedCashFlow

# Register IndexedCashFlow in _QuantLib:
_QuantLib.IndexedCashFlow_swigregister(IndexedCashFlow)

def as_indexed_cashflow(cf):
    r"""as_indexed_cashflow(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< IndexedCashFlow >"""
    return _QuantLib.as_indexed_cashflow(cf)
class Coupon(CashFlow):
    r"""Proxy of C++ Coupon class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def nominal(self):
        r"""nominal(Coupon self) -> Real"""
        return _QuantLib.Coupon_nominal(self)

    def accrualStartDate(self):
        r"""accrualStartDate(Coupon self) -> Date"""
        return _QuantLib.Coupon_accrualStartDate(self)

    def accrualEndDate(self):
        r"""accrualEndDate(Coupon self) -> Date"""
        return _QuantLib.Coupon_accrualEndDate(self)

    def referencePeriodStart(self):
        r"""referencePeriodStart(Coupon self) -> Date"""
        return _QuantLib.Coupon_referencePeriodStart(self)

    def referencePeriodEnd(self):
        r"""referencePeriodEnd(Coupon self) -> Date"""
        return _QuantLib.Coupon_referencePeriodEnd(self)

    def exCouponDate(self):
        r"""exCouponDate(Coupon self) -> Date"""
        return _QuantLib.Coupon_exCouponDate(self)

    def rate(self):
        r"""rate(Coupon self) -> Real"""
        return _QuantLib.Coupon_rate(self)

    def accrualPeriod(self):
        r"""accrualPeriod(Coupon self) -> Time"""
        return _QuantLib.Coupon_accrualPeriod(self)

    def accrualDays(self):
        r"""accrualDays(Coupon self) -> BigInteger"""
        return _QuantLib.Coupon_accrualDays(self)

    def dayCounter(self):
        r"""dayCounter(Coupon self) -> DayCounter"""
        return _QuantLib.Coupon_dayCounter(self)

    def accruedAmount(self, date):
        r"""accruedAmount(Coupon self, Date date) -> Real"""
        return _QuantLib.Coupon_accruedAmount(self, date)
    __swig_destroy__ = _QuantLib.delete_Coupon

# Register Coupon in _QuantLib:
_QuantLib.Coupon_swigregister(Coupon)

def as_coupon(cf):
    r"""as_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< Coupon >"""
    return _QuantLib.as_coupon(cf)
class FixedRateCoupon(Coupon):
    r"""Proxy of C++ FixedRateCoupon class."""

    thisown = 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):
        r"""__init__(FixedRateCoupon self, Date paymentDate, Real nominal, Rate rate, DayCounter dayCounter, Date startDate, Date endDate, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date()) -> FixedRateCoupon"""
        _QuantLib.FixedRateCoupon_swiginit(self, _QuantLib.new_FixedRateCoupon(*args, **kwargs))

    def interestRate(self):
        r"""interestRate(FixedRateCoupon self) -> InterestRate"""
        return _QuantLib.FixedRateCoupon_interestRate(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateCoupon

# Register FixedRateCoupon in _QuantLib:
_QuantLib.FixedRateCoupon_swigregister(FixedRateCoupon)

def as_fixed_rate_coupon(cf):
    r"""as_fixed_rate_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< FixedRateCoupon >"""
    return _QuantLib.as_fixed_rate_coupon(cf)
class FloatingRateCouponPricer(object):
    r"""Proxy of C++ FloatingRateCouponPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def swapletPrice(self):
        r"""swapletPrice(FloatingRateCouponPricer self) -> Real"""
        return _QuantLib.FloatingRateCouponPricer_swapletPrice(self)

    def swapletRate(self):
        r"""swapletRate(FloatingRateCouponPricer self) -> Rate"""
        return _QuantLib.FloatingRateCouponPricer_swapletRate(self)

    def capletPrice(self, effectiveCap):
        r"""capletPrice(FloatingRateCouponPricer self, Rate effectiveCap) -> Real"""
        return _QuantLib.FloatingRateCouponPricer_capletPrice(self, effectiveCap)

    def capletRate(self, effectiveCap):
        r"""capletRate(FloatingRateCouponPricer self, Rate effectiveCap) -> Rate"""
        return _QuantLib.FloatingRateCouponPricer_capletRate(self, effectiveCap)

    def floorletPrice(self, effectiveFloor):
        r"""floorletPrice(FloatingRateCouponPricer self, Rate effectiveFloor) -> Real"""
        return _QuantLib.FloatingRateCouponPricer_floorletPrice(self, effectiveFloor)

    def floorletRate(self, effectiveFloor):
        r"""floorletRate(FloatingRateCouponPricer self, Rate effectiveFloor) -> Rate"""
        return _QuantLib.FloatingRateCouponPricer_floorletRate(self, effectiveFloor)
    __swig_destroy__ = _QuantLib.delete_FloatingRateCouponPricer

# Register FloatingRateCouponPricer in _QuantLib:
_QuantLib.FloatingRateCouponPricer_swigregister(FloatingRateCouponPricer)
class FloatingRateCoupon(Coupon):
    r"""Proxy of C++ FloatingRateCoupon class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def fixingDate(self):
        r"""fixingDate(FloatingRateCoupon self) -> Date"""
        return _QuantLib.FloatingRateCoupon_fixingDate(self)

    def fixingDays(self):
        r"""fixingDays(FloatingRateCoupon self) -> Integer"""
        return _QuantLib.FloatingRateCoupon_fixingDays(self)

    def isInArrears(self):
        r"""isInArrears(FloatingRateCoupon self) -> bool"""
        return _QuantLib.FloatingRateCoupon_isInArrears(self)

    def gearing(self):
        r"""gearing(FloatingRateCoupon self) -> Real"""
        return _QuantLib.FloatingRateCoupon_gearing(self)

    def spread(self):
        r"""spread(FloatingRateCoupon self) -> Rate"""
        return _QuantLib.FloatingRateCoupon_spread(self)

    def indexFixing(self):
        r"""indexFixing(FloatingRateCoupon self) -> Rate"""
        return _QuantLib.FloatingRateCoupon_indexFixing(self)

    def adjustedFixing(self):
        r"""adjustedFixing(FloatingRateCoupon self) -> Rate"""
        return _QuantLib.FloatingRateCoupon_adjustedFixing(self)

    def convexityAdjustment(self):
        r"""convexityAdjustment(FloatingRateCoupon self) -> Rate"""
        return _QuantLib.FloatingRateCoupon_convexityAdjustment(self)

    def price(self, discountCurve):
        r"""price(FloatingRateCoupon self, YieldTermStructureHandle discountCurve) -> Real"""
        return _QuantLib.FloatingRateCoupon_price(self, discountCurve)

    def index(self):
        r"""index(FloatingRateCoupon self) -> ext::shared_ptr< InterestRateIndex >"""
        return _QuantLib.FloatingRateCoupon_index(self)

    def setPricer(self, p):
        r"""setPricer(FloatingRateCoupon self, ext::shared_ptr< FloatingRateCouponPricer > const & p)"""
        return _QuantLib.FloatingRateCoupon_setPricer(self, p)
    __swig_destroy__ = _QuantLib.delete_FloatingRateCoupon

# Register FloatingRateCoupon in _QuantLib:
_QuantLib.FloatingRateCoupon_swigregister(FloatingRateCoupon)

def as_floating_rate_coupon(cf):
    r"""as_floating_rate_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< FloatingRateCoupon >"""
    return _QuantLib.as_floating_rate_coupon(cf)
class RateAveraging(object):
    r"""Proxy of C++ RateAveraging class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Simple = _QuantLib.RateAveraging_Simple
    
    Compound = _QuantLib.RateAveraging_Compound
    

    def __init__(self):
        r"""__init__(RateAveraging self) -> RateAveraging"""
        _QuantLib.RateAveraging_swiginit(self, _QuantLib.new_RateAveraging())
    __swig_destroy__ = _QuantLib.delete_RateAveraging

# Register RateAveraging in _QuantLib:
_QuantLib.RateAveraging_swigregister(RateAveraging)
class OvernightIndexedCoupon(FloatingRateCoupon):
    r"""Proxy of C++ OvernightIndexedCoupon class."""

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

    def __init__(self, *args):
        r"""__init__(OvernightIndexedCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< OvernightIndex > const & overnightIndex, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound) -> OvernightIndexedCoupon"""
        _QuantLib.OvernightIndexedCoupon_swiginit(self, _QuantLib.new_OvernightIndexedCoupon(*args))

    def fixingDates(self):
        r"""fixingDates(OvernightIndexedCoupon self) -> DateVector"""
        return _QuantLib.OvernightIndexedCoupon_fixingDates(self)

    def dt(self):
        r"""dt(OvernightIndexedCoupon self) -> DoubleVector"""
        return _QuantLib.OvernightIndexedCoupon_dt(self)

    def indexFixings(self):
        r"""indexFixings(OvernightIndexedCoupon self) -> DoubleVector"""
        return _QuantLib.OvernightIndexedCoupon_indexFixings(self)

    def valueDates(self):
        r"""valueDates(OvernightIndexedCoupon self) -> DateVector"""
        return _QuantLib.OvernightIndexedCoupon_valueDates(self)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexedCoupon

# Register OvernightIndexedCoupon in _QuantLib:
_QuantLib.OvernightIndexedCoupon_swigregister(OvernightIndexedCoupon)

def as_overnight_indexed_coupon(cf):
    r"""as_overnight_indexed_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< OvernightIndexedCoupon >"""
    return _QuantLib.as_overnight_indexed_coupon(cf)
class CappedFlooredCoupon(FloatingRateCoupon):
    r"""Proxy of C++ CappedFlooredCoupon class."""

    thisown = 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):
        r"""__init__(CappedFlooredCoupon self, ext::shared_ptr< FloatingRateCoupon > const & underlying, Rate cap=Null< Rate >(), Rate floor=Null< Rate >()) -> CappedFlooredCoupon"""
        _QuantLib.CappedFlooredCoupon_swiginit(self, _QuantLib.new_CappedFlooredCoupon(*args, **kwargs))

    def cap(self):
        r"""cap(CappedFlooredCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredCoupon_cap(self)

    def floor(self):
        r"""floor(CappedFlooredCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredCoupon_floor(self)

    def effectiveCap(self):
        r"""effectiveCap(CappedFlooredCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredCoupon_effectiveCap(self)

    def effectiveFloor(self):
        r"""effectiveFloor(CappedFlooredCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredCoupon_effectiveFloor(self)

    def isCapped(self):
        r"""isCapped(CappedFlooredCoupon self) -> bool"""
        return _QuantLib.CappedFlooredCoupon_isCapped(self)

    def isFloored(self):
        r"""isFloored(CappedFlooredCoupon self) -> bool"""
        return _QuantLib.CappedFlooredCoupon_isFloored(self)

    def setPricer(self, p):
        r"""setPricer(CappedFlooredCoupon self, ext::shared_ptr< FloatingRateCouponPricer > const & p)"""
        return _QuantLib.CappedFlooredCoupon_setPricer(self, p)
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCoupon

# Register CappedFlooredCoupon in _QuantLib:
_QuantLib.CappedFlooredCoupon_swigregister(CappedFlooredCoupon)
class IborCoupon(FloatingRateCoupon):
    r"""Proxy of C++ IborCoupon class."""

    thisown = 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):
        r"""__init__(IborCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Integer fixingDays, ext::shared_ptr< IborIndex > & index, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> IborCoupon"""
        _QuantLib.IborCoupon_swiginit(self, _QuantLib.new_IborCoupon(*args, **kwargs))

    @staticmethod
    def createAtParCoupons():
        r"""createAtParCoupons()"""
        return _QuantLib.IborCoupon_createAtParCoupons()

    @staticmethod
    def createIndexedCoupons():
        r"""createIndexedCoupons()"""
        return _QuantLib.IborCoupon_createIndexedCoupons()

    @staticmethod
    def usingAtParCoupons():
        r"""usingAtParCoupons() -> bool"""
        return _QuantLib.IborCoupon_usingAtParCoupons()
    __swig_destroy__ = _QuantLib.delete_IborCoupon

# Register IborCoupon in _QuantLib:
_QuantLib.IborCoupon_swigregister(IborCoupon)
class CappedFlooredIborCoupon(CappedFlooredCoupon):
    r"""Proxy of C++ CappedFlooredIborCoupon class."""

    thisown = 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):
        r"""__init__(CappedFlooredIborCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Integer fixingDays, ext::shared_ptr< IborIndex > & index, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CappedFlooredIborCoupon"""
        _QuantLib.CappedFlooredIborCoupon_swiginit(self, _QuantLib.new_CappedFlooredIborCoupon(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CappedFlooredIborCoupon

# Register CappedFlooredIborCoupon in _QuantLib:
_QuantLib.CappedFlooredIborCoupon_swigregister(CappedFlooredIborCoupon)
class SubPeriodsCoupon(FloatingRateCoupon):
    r"""Proxy of C++ SubPeriodsCoupon class."""

    thisown = 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):
        r"""__init__(SubPeriodsCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< IborIndex > const & index, Real gearing=1.0, Rate couponSpread=0.0, Rate rateSpread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), Date exCouponDate=Date()) -> SubPeriodsCoupon"""
        _QuantLib.SubPeriodsCoupon_swiginit(self, _QuantLib.new_SubPeriodsCoupon(*args, **kwargs))

    def fixingDates(self):
        r"""fixingDates(SubPeriodsCoupon self) -> DateVector"""
        return _QuantLib.SubPeriodsCoupon_fixingDates(self)

    def dt(self):
        r"""dt(SubPeriodsCoupon self) -> DoubleVector"""
        return _QuantLib.SubPeriodsCoupon_dt(self)

    def valueDates(self):
        r"""valueDates(SubPeriodsCoupon self) -> DateVector"""
        return _QuantLib.SubPeriodsCoupon_valueDates(self)

    def rateSpread(self):
        r"""rateSpread(SubPeriodsCoupon self) -> Spread"""
        return _QuantLib.SubPeriodsCoupon_rateSpread(self)
    __swig_destroy__ = _QuantLib.delete_SubPeriodsCoupon

# Register SubPeriodsCoupon in _QuantLib:
_QuantLib.SubPeriodsCoupon_swigregister(SubPeriodsCoupon)

def as_sub_periods_coupon(cf):
    r"""as_sub_periods_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< SubPeriodsCoupon >"""
    return _QuantLib.as_sub_periods_coupon(cf)
class IborCouponPricer(FloatingRateCouponPricer):
    r"""Proxy of C++ IborCouponPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def capletVolatility(self):
        r"""capletVolatility(IborCouponPricer self) -> OptionletVolatilityStructureHandle"""
        return _QuantLib.IborCouponPricer_capletVolatility(self)

    def setCapletVolatility(self, *args):
        r"""setCapletVolatility(IborCouponPricer self, OptionletVolatilityStructureHandle v=Handle< OptionletVolatilityStructure >())"""
        return _QuantLib.IborCouponPricer_setCapletVolatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_IborCouponPricer

# Register IborCouponPricer in _QuantLib:
_QuantLib.IborCouponPricer_swigregister(IborCouponPricer)
class BlackIborCouponPricer(IborCouponPricer):
    r"""Proxy of C++ BlackIborCouponPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Black76 = _QuantLib.BlackIborCouponPricer_Black76
    
    BivariateLognormal = _QuantLib.BlackIborCouponPricer_BivariateLognormal
    

    def __init__(self, *args, **kwargs):
        r"""__init__(BlackIborCouponPricer self, OptionletVolatilityStructureHandle v=Handle< OptionletVolatilityStructure >(), BlackIborCouponPricer::TimingAdjustment const timingAdjustment=Black76, QuoteHandle correlation=Handle< Quote >(ext::shared_ptr<Quote>(new SimpleQuote(1.0))), boost::optional< bool > useIndexedCoupon=boost::none) -> BlackIborCouponPricer"""
        _QuantLib.BlackIborCouponPricer_swiginit(self, _QuantLib.new_BlackIborCouponPricer(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_BlackIborCouponPricer

# Register BlackIborCouponPricer in _QuantLib:
_QuantLib.BlackIborCouponPricer_swigregister(BlackIborCouponPricer)
class SubPeriodsPricer(FloatingRateCouponPricer):
    r"""Proxy of C++ SubPeriodsPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register SubPeriodsPricer in _QuantLib:
_QuantLib.SubPeriodsPricer_swigregister(SubPeriodsPricer)
class CompoundingRatePricer(SubPeriodsPricer):
    r"""Proxy of C++ CompoundingRatePricer class."""

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

    def __init__(self):
        r"""__init__(CompoundingRatePricer self) -> CompoundingRatePricer"""
        _QuantLib.CompoundingRatePricer_swiginit(self, _QuantLib.new_CompoundingRatePricer())
    __swig_destroy__ = _QuantLib.delete_CompoundingRatePricer

# Register CompoundingRatePricer in _QuantLib:
_QuantLib.CompoundingRatePricer_swigregister(CompoundingRatePricer)
class AveragingRatePricer(SubPeriodsPricer):
    r"""Proxy of C++ AveragingRatePricer class."""

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

    def __init__(self):
        r"""__init__(AveragingRatePricer self) -> AveragingRatePricer"""
        _QuantLib.AveragingRatePricer_swiginit(self, _QuantLib.new_AveragingRatePricer())
    __swig_destroy__ = _QuantLib.delete_AveragingRatePricer

# Register AveragingRatePricer in _QuantLib:
_QuantLib.AveragingRatePricer_swigregister(AveragingRatePricer)
class CmsCoupon(FloatingRateCoupon):
    r"""Proxy of C++ CmsCoupon class."""

    thisown = 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):
        r"""__init__(CmsCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Integer fixingDays, ext::shared_ptr< SwapIndex > const & index, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CmsCoupon"""
        _QuantLib.CmsCoupon_swiginit(self, _QuantLib.new_CmsCoupon(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CmsCoupon

# Register CmsCoupon in _QuantLib:
_QuantLib.CmsCoupon_swigregister(CmsCoupon)
class CmsSpreadCoupon(FloatingRateCoupon):
    r"""Proxy of C++ CmsSpreadCoupon class."""

    thisown = 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):
        r"""__init__(CmsSpreadCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< SwapSpreadIndex > const & index, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CmsSpreadCoupon"""
        _QuantLib.CmsSpreadCoupon_swiginit(self, _QuantLib.new_CmsSpreadCoupon(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CmsSpreadCoupon

# Register CmsSpreadCoupon in _QuantLib:
_QuantLib.CmsSpreadCoupon_swigregister(CmsSpreadCoupon)
class CmsCouponPricer(FloatingRateCouponPricer):
    r"""Proxy of C++ CmsCouponPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def swaptionVolatility(self):
        r"""swaptionVolatility(CmsCouponPricer self) -> SwaptionVolatilityStructureHandle"""
        return _QuantLib.CmsCouponPricer_swaptionVolatility(self)

    def setSwaptionVolatility(self, *args):
        r"""setSwaptionVolatility(CmsCouponPricer self, SwaptionVolatilityStructureHandle v=Handle< SwaptionVolatilityStructure >())"""
        return _QuantLib.CmsCouponPricer_setSwaptionVolatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_CmsCouponPricer

# Register CmsCouponPricer in _QuantLib:
_QuantLib.CmsCouponPricer_swigregister(CmsCouponPricer)
class CmsCouponPricerVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< CmsCouponPricer > > class."""

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

    def iterator(self):
        r"""iterator(CmsCouponPricerVector self) -> SwigPyIterator"""
        return _QuantLib.CmsCouponPricerVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(CmsCouponPricerVector self) -> bool"""
        return _QuantLib.CmsCouponPricerVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CmsCouponPricerVector self) -> bool"""
        return _QuantLib.CmsCouponPricerVector___bool__(self)

    def __len__(self):
        r"""__len__(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type"""
        return _QuantLib.CmsCouponPricerVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j) -> CmsCouponPricerVector"""
        return _QuantLib.CmsCouponPricerVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j)
        __setslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j, CmsCouponPricerVector v)
        """
        return _QuantLib.CmsCouponPricerVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j)"""
        return _QuantLib.CmsCouponPricerVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i)
        __delitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.CmsCouponPricerVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice) -> CmsCouponPricerVector
        __getitem__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &
        """
        return _QuantLib.CmsCouponPricerVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice, CmsCouponPricerVector v)
        __setitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)
        """
        return _QuantLib.CmsCouponPricerVector___setitem__(self, *args)

    def pop(self):
        r"""pop(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type"""
        return _QuantLib.CmsCouponPricerVector_pop(self)

    def append(self, x):
        r"""append(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)"""
        return _QuantLib.CmsCouponPricerVector_append(self, x)

    def empty(self):
        r"""empty(CmsCouponPricerVector self) -> bool"""
        return _QuantLib.CmsCouponPricerVector_empty(self)

    def size(self):
        r"""size(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type"""
        return _QuantLib.CmsCouponPricerVector_size(self)

    def swap(self, v):
        r"""swap(CmsCouponPricerVector self, CmsCouponPricerVector v)"""
        return _QuantLib.CmsCouponPricerVector_swap(self, v)

    def begin(self):
        r"""begin(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator"""
        return _QuantLib.CmsCouponPricerVector_begin(self)

    def end(self):
        r"""end(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator"""
        return _QuantLib.CmsCouponPricerVector_end(self)

    def rbegin(self):
        r"""rbegin(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator"""
        return _QuantLib.CmsCouponPricerVector_rbegin(self)

    def rend(self):
        r"""rend(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator"""
        return _QuantLib.CmsCouponPricerVector_rend(self)

    def clear(self):
        r"""clear(CmsCouponPricerVector self)"""
        return _QuantLib.CmsCouponPricerVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::allocator_type"""
        return _QuantLib.CmsCouponPricerVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(CmsCouponPricerVector self)"""
        return _QuantLib.CmsCouponPricerVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator
        erase(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator first, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator last) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator
        """
        return _QuantLib.CmsCouponPricerVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CmsCouponPricerVector self) -> CmsCouponPricerVector
        __init__(CmsCouponPricerVector self, CmsCouponPricerVector other) -> CmsCouponPricerVector
        __init__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type size) -> CmsCouponPricerVector
        __init__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type size, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & value) -> CmsCouponPricerVector
        """
        _QuantLib.CmsCouponPricerVector_swiginit(self, _QuantLib.new_CmsCouponPricerVector(*args))

    def push_back(self, x):
        r"""push_back(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)"""
        return _QuantLib.CmsCouponPricerVector_push_back(self, x)

    def front(self):
        r"""front(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &"""
        return _QuantLib.CmsCouponPricerVector_front(self)

    def back(self):
        r"""back(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &"""
        return _QuantLib.CmsCouponPricerVector_back(self)

    def assign(self, n, x):
        r"""assign(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)"""
        return _QuantLib.CmsCouponPricerVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type new_size)
        resize(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type new_size, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)
        """
        return _QuantLib.CmsCouponPricerVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator
        insert(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)
        """
        return _QuantLib.CmsCouponPricerVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n)"""
        return _QuantLib.CmsCouponPricerVector_reserve(self, n)

    def capacity(self):
        r"""capacity(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type"""
        return _QuantLib.CmsCouponPricerVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CmsCouponPricerVector

# Register CmsCouponPricerVector in _QuantLib:
_QuantLib.CmsCouponPricerVector_swigregister(CmsCouponPricerVector)
class GFunctionFactory(object):
    r"""Proxy of C++ GFunctionFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Standard = _QuantLib.GFunctionFactory_Standard
    
    ExactYield = _QuantLib.GFunctionFactory_ExactYield
    
    ParallelShifts = _QuantLib.GFunctionFactory_ParallelShifts
    
    NonParallelShifts = _QuantLib.GFunctionFactory_NonParallelShifts
    
    __swig_destroy__ = _QuantLib.delete_GFunctionFactory

# Register GFunctionFactory in _QuantLib:
_QuantLib.GFunctionFactory_swigregister(GFunctionFactory)
class AnalyticHaganPricer(CmsCouponPricer):
    r"""Proxy of C++ AnalyticHaganPricer class."""

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

    def __init__(self, v, model, meanReversion):
        r"""__init__(AnalyticHaganPricer self, SwaptionVolatilityStructureHandle v, GFunctionFactory::YieldCurveModel model, QuoteHandle meanReversion) -> AnalyticHaganPricer"""
        _QuantLib.AnalyticHaganPricer_swiginit(self, _QuantLib.new_AnalyticHaganPricer(v, model, meanReversion))
    __swig_destroy__ = _QuantLib.delete_AnalyticHaganPricer

# Register AnalyticHaganPricer in _QuantLib:
_QuantLib.AnalyticHaganPricer_swigregister(AnalyticHaganPricer)
class NumericHaganPricer(CmsCouponPricer):
    r"""Proxy of C++ NumericHaganPricer class."""

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

    def __init__(self, v, model, meanReversion, lowerLimit=0.0, upperLimit=1.0, precision=1.0e-6):
        r"""__init__(NumericHaganPricer self, SwaptionVolatilityStructureHandle v, GFunctionFactory::YieldCurveModel model, QuoteHandle meanReversion, Rate lowerLimit=0.0, Rate upperLimit=1.0, Real precision=1.0e-6) -> NumericHaganPricer"""
        _QuantLib.NumericHaganPricer_swiginit(self, _QuantLib.new_NumericHaganPricer(v, model, meanReversion, lowerLimit, upperLimit, precision))
    __swig_destroy__ = _QuantLib.delete_NumericHaganPricer

# Register NumericHaganPricer in _QuantLib:
_QuantLib.NumericHaganPricer_swigregister(NumericHaganPricer)
class CappedFlooredCmsCoupon(CappedFlooredCoupon):
    r"""Proxy of C++ CappedFlooredCmsCoupon class."""

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

    def __init__(self, *args):
        r"""__init__(CappedFlooredCmsCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< SwapIndex > const & index, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CappedFlooredCmsCoupon"""
        _QuantLib.CappedFlooredCmsCoupon_swiginit(self, _QuantLib.new_CappedFlooredCmsCoupon(*args))
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCmsCoupon

# Register CappedFlooredCmsCoupon in _QuantLib:
_QuantLib.CappedFlooredCmsCoupon_swigregister(CappedFlooredCmsCoupon)
class CappedFlooredCmsSpreadCoupon(CappedFlooredCoupon):
    r"""Proxy of C++ CappedFlooredCmsSpreadCoupon class."""

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

    def __init__(self, *args):
        r"""__init__(CappedFlooredCmsSpreadCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< SwapSpreadIndex > const & index, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CappedFlooredCmsSpreadCoupon"""
        _QuantLib.CappedFlooredCmsSpreadCoupon_swiginit(self, _QuantLib.new_CappedFlooredCmsSpreadCoupon(*args))
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCmsSpreadCoupon

# Register CappedFlooredCmsSpreadCoupon in _QuantLib:
_QuantLib.CappedFlooredCmsSpreadCoupon_swigregister(CappedFlooredCmsSpreadCoupon)
class LinearTsrPricer(CmsCouponPricer):
    r"""Proxy of C++ LinearTsrPricer class."""

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

    def __init__(self, *args):
        r"""__init__(LinearTsrPricer self, SwaptionVolatilityStructureHandle swaptionVol, QuoteHandle meanReversion, YieldTermStructureHandle couponDiscountCurve=Handle< YieldTermStructure >(), LinearTsrPricerSettings settings=LinearTsrPricer::Settings()) -> LinearTsrPricer"""
        _QuantLib.LinearTsrPricer_swiginit(self, _QuantLib.new_LinearTsrPricer(*args))
    __swig_destroy__ = _QuantLib.delete_LinearTsrPricer

# Register LinearTsrPricer in _QuantLib:
_QuantLib.LinearTsrPricer_swigregister(LinearTsrPricer)
class LinearTsrPricerSettings(object):
    r"""Proxy of C++ LinearTsrPricer::Settings class."""

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

    def __init__(self):
        r"""__init__(LinearTsrPricerSettings self) -> LinearTsrPricerSettings"""
        _QuantLib.LinearTsrPricerSettings_swiginit(self, _QuantLib.new_LinearTsrPricerSettings())

    def withRateBound(self, lowerRateBound=0.0001, upperRateBound=2.0000):
        r"""withRateBound(LinearTsrPricerSettings self, Real const lowerRateBound=0.0001, Real const upperRateBound=2.0000) -> LinearTsrPricerSettings"""
        return _QuantLib.LinearTsrPricerSettings_withRateBound(self, lowerRateBound, upperRateBound)

    def withVegaRatio(self, *args):
        r"""
        withVegaRatio(LinearTsrPricerSettings self, Real const vegaRatio=0.01) -> LinearTsrPricerSettings
        withVegaRatio(LinearTsrPricerSettings self, Real const vegaRatio, Real const lowerRateBound, Real const upperRateBound) -> LinearTsrPricerSettings
        """
        return _QuantLib.LinearTsrPricerSettings_withVegaRatio(self, *args)

    def withPriceThreshold(self, *args):
        r"""
        withPriceThreshold(LinearTsrPricerSettings self, Real const priceThreshold=1.0E-8) -> LinearTsrPricerSettings
        withPriceThreshold(LinearTsrPricerSettings self, Real const priceThreshold, Real const lowerRateBound, Real const upperRateBound) -> LinearTsrPricerSettings
        """
        return _QuantLib.LinearTsrPricerSettings_withPriceThreshold(self, *args)

    def withBSStdDevs(self, *args):
        r"""
        withBSStdDevs(LinearTsrPricerSettings self, Real const stdDevs=3.0) -> LinearTsrPricerSettings
        withBSStdDevs(LinearTsrPricerSettings self, Real const stdDevs, Real const lowerRateBound, Real const upperRateBound) -> LinearTsrPricerSettings
        """
        return _QuantLib.LinearTsrPricerSettings_withBSStdDevs(self, *args)
    RateBound = _QuantLib.LinearTsrPricerSettings_RateBound
    
    VegaRatio = _QuantLib.LinearTsrPricerSettings_VegaRatio
    
    PriceThreshold = _QuantLib.LinearTsrPricerSettings_PriceThreshold
    
    BSStdDevs = _QuantLib.LinearTsrPricerSettings_BSStdDevs
    
    __swig_destroy__ = _QuantLib.delete_LinearTsrPricerSettings

# Register LinearTsrPricerSettings in _QuantLib:
_QuantLib.LinearTsrPricerSettings_swigregister(LinearTsrPricerSettings)
class CmsSpreadCouponPricer(FloatingRateCouponPricer):
    r"""Proxy of C++ CmsSpreadCouponPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def correlation(self):
        r"""correlation(CmsSpreadCouponPricer self) -> QuoteHandle"""
        return _QuantLib.CmsSpreadCouponPricer_correlation(self)

    def setCorrelation(self, *args):
        r"""setCorrelation(CmsSpreadCouponPricer self, QuoteHandle correlation=Handle< Quote >())"""
        return _QuantLib.CmsSpreadCouponPricer_setCorrelation(self, *args)
    __swig_destroy__ = _QuantLib.delete_CmsSpreadCouponPricer

# Register CmsSpreadCouponPricer in _QuantLib:
_QuantLib.CmsSpreadCouponPricer_swigregister(CmsSpreadCouponPricer)
class LognormalCmsSpreadPricer(CmsSpreadCouponPricer):
    r"""Proxy of C++ LognormalCmsSpreadPricer class."""

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

    def __init__(self, *args):
        r"""__init__(LognormalCmsSpreadPricer self, ext::shared_ptr< CmsCouponPricer > const & cmsPricer, QuoteHandle correlation, YieldTermStructureHandle couponDiscountCurve=Handle< YieldTermStructure >(), Size const IntegrationPoints=16, boost::optional< VolatilityType > const volatilityType=boost::none, Real const shift1=Null< Real >(), Real const shift2=Null< Real >()) -> LognormalCmsSpreadPricer"""
        _QuantLib.LognormalCmsSpreadPricer_swiginit(self, _QuantLib.new_LognormalCmsSpreadPricer(*args))

    def swapletPrice(self):
        r"""swapletPrice(LognormalCmsSpreadPricer self) -> Real"""
        return _QuantLib.LognormalCmsSpreadPricer_swapletPrice(self)

    def swapletRate(self):
        r"""swapletRate(LognormalCmsSpreadPricer self) -> Rate"""
        return _QuantLib.LognormalCmsSpreadPricer_swapletRate(self)

    def capletPrice(self, effectiveCap):
        r"""capletPrice(LognormalCmsSpreadPricer self, Rate effectiveCap) -> Real"""
        return _QuantLib.LognormalCmsSpreadPricer_capletPrice(self, effectiveCap)

    def capletRate(self, effectiveCap):
        r"""capletRate(LognormalCmsSpreadPricer self, Rate effectiveCap) -> Rate"""
        return _QuantLib.LognormalCmsSpreadPricer_capletRate(self, effectiveCap)

    def floorletPrice(self, effectiveFloor):
        r"""floorletPrice(LognormalCmsSpreadPricer self, Rate effectiveFloor) -> Real"""
        return _QuantLib.LognormalCmsSpreadPricer_floorletPrice(self, effectiveFloor)

    def floorletRate(self, effectiveFloor):
        r"""floorletRate(LognormalCmsSpreadPricer self, Rate effectiveFloor) -> Rate"""
        return _QuantLib.LognormalCmsSpreadPricer_floorletRate(self, effectiveFloor)
    __swig_destroy__ = _QuantLib.delete_LognormalCmsSpreadPricer

# Register LognormalCmsSpreadPricer in _QuantLib:
_QuantLib.LognormalCmsSpreadPricer_swigregister(LognormalCmsSpreadPricer)

def FixedRateLeg(*args, **kwargs):
    r"""FixedRateLeg(Schedule schedule, DayCounter dayCount, DoubleVector nominals, DoubleVector couponRates, BusinessDayConvention paymentAdjustment=Following, DayCounter firstPeriodDayCount=DayCounter(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, Calendar paymentCalendar=Calendar(), Natural paymentLag=0, Compounding compounding=Simple, Frequency compoundingFrequency=Annual) -> Leg"""
    return _QuantLib.FixedRateLeg(*args, **kwargs)

def IborLeg(*args, **kwargs):
    r"""IborLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool isInArrears=False, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, Calendar paymentCalendar=Calendar(), Natural paymentLag=0, boost::optional< bool > withIndexedCoupons=boost::none) -> Leg"""
    return _QuantLib.IborLeg(*args, **kwargs)

def OvernightLeg(*args, **kwargs):
    r"""OvernightLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< OvernightIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound, Calendar paymentCalendar=Calendar(), Natural paymentLag=0) -> Leg"""
    return _QuantLib.OvernightLeg(*args, **kwargs)

def CmsLeg(*args, **kwargs):
    r"""CmsLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool isInArrears=False, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> Leg"""
    return _QuantLib.CmsLeg(*args, **kwargs)

def CmsZeroLeg(*args, **kwargs):
    r"""CmsZeroLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> Leg"""
    return _QuantLib.CmsZeroLeg(*args, **kwargs)

def CmsSpreadLeg(*args, **kwargs):
    r"""CmsSpreadLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< SwapSpreadIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool isInArrears=False) -> Leg"""
    return _QuantLib.CmsSpreadLeg(*args, **kwargs)

def SubPeriodsLeg(*args, **kwargs):
    r"""SubPeriodsLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, Calendar paymentCalendar=Calendar(), Natural paymentLag=0, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector couponSpreads=std::vector< Spread >(), DoubleVector rateSpreads=std::vector< Spread >(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, RateAveraging::Type averagingMethod=Compound) -> Leg"""
    return _QuantLib.SubPeriodsLeg(*args, **kwargs)
class Duration(object):
    r"""Proxy of C++ Duration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Simple = _QuantLib.Duration_Simple
    
    Macaulay = _QuantLib.Duration_Macaulay
    
    Modified = _QuantLib.Duration_Modified
    

    def __init__(self):
        r"""__init__(Duration self) -> Duration"""
        _QuantLib.Duration_swiginit(self, _QuantLib.new_Duration())
    __swig_destroy__ = _QuantLib.delete_Duration

# Register Duration in _QuantLib:
_QuantLib.Duration_swigregister(Duration)
class CashFlows(object):
    r"""Proxy of C++ CashFlows class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def startDate(arg1):
        r"""startDate(Leg arg1) -> Date"""
        return _QuantLib.CashFlows_startDate(arg1)

    @staticmethod
    def maturityDate(arg1):
        r"""maturityDate(Leg arg1) -> Date"""
        return _QuantLib.CashFlows_maturityDate(arg1)

    @staticmethod
    def previousCashFlowDate(*args):
        r"""previousCashFlowDate(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Date"""
        return _QuantLib.CashFlows_previousCashFlowDate(*args)

    @staticmethod
    def nextCashFlowDate(*args):
        r"""nextCashFlowDate(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Date"""
        return _QuantLib.CashFlows_nextCashFlowDate(*args)

    @staticmethod
    def previousCashFlowAmount(*args):
        r"""previousCashFlowAmount(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Real"""
        return _QuantLib.CashFlows_previousCashFlowAmount(*args)

    @staticmethod
    def nextCashFlowAmount(*args):
        r"""nextCashFlowAmount(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Real"""
        return _QuantLib.CashFlows_nextCashFlowAmount(*args)

    @staticmethod
    def previousCashFlow(*args):
        r"""previousCashFlow(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> ext::shared_ptr< CashFlow >"""
        return _QuantLib.CashFlows_previousCashFlow(*args)

    @staticmethod
    def nextCashFlow(*args):
        r"""nextCashFlow(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> ext::shared_ptr< CashFlow >"""
        return _QuantLib.CashFlows_nextCashFlow(*args)

    @staticmethod
    def npv(*args):
        r"""
        npv(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, Spread zSpread, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        npv(Leg leg, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        npv(Leg arg1, InterestRate arg2, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        npv(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        """
        return _QuantLib.CashFlows_npv(*args)

    @staticmethod
    def bps(*args):
        r"""
        bps(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        bps(Leg leg, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        bps(Leg arg1, InterestRate arg2, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        bps(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        """
        return _QuantLib.CashFlows_bps(*args)

    @staticmethod
    def npvbps(*args):
        r"""
        npvbps(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> DoublePair
        npvbps(Leg leg, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> DoublePair
        """
        return _QuantLib.CashFlows_npvbps(*args)

    @staticmethod
    def atmRate(*args):
        r"""atmRate(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date(), Real npv=Null< Real >()) -> Rate"""
        return _QuantLib.CashFlows_atmRate(*args)

    @staticmethod
    def yieldRate(*args):
        r"""yieldRate(Leg arg1, Real npv, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date(), Real accuracy=1.0e-10, Size maxIterations=10000, Rate guess=0.05) -> Rate"""
        return _QuantLib.CashFlows_yieldRate(*args)

    @staticmethod
    def duration(*args):
        r"""
        duration(Leg arg1, InterestRate arg2, Duration::Type type, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Time
        duration(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Duration::Type type, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Time
        """
        return _QuantLib.CashFlows_duration(*args)

    @staticmethod
    def convexity(*args):
        r"""
        convexity(Leg arg1, InterestRate arg2, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        convexity(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        """
        return _QuantLib.CashFlows_convexity(*args)

    @staticmethod
    def basisPointValue(*args):
        r"""
        basisPointValue(Leg leg, InterestRate _yield, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        basisPointValue(Leg leg, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real
        """
        return _QuantLib.CashFlows_basisPointValue(*args)

    @staticmethod
    def zSpread(*args):
        r"""zSpread(Leg leg, Real npv, ext::shared_ptr< YieldTermStructure > const & arg3, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date(), Real accuracy=1.0e-10, Size maxIterations=100, Rate guess=0.0) -> Spread"""
        return _QuantLib.CashFlows_zSpread(*args)
    __swig_destroy__ = _QuantLib.delete_CashFlows

# Register CashFlows in _QuantLib:
_QuantLib.CashFlows_swigregister(CashFlows)
class CalibrationHelper(object):
    r"""Proxy of C++ CalibrationHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def calibrationError(self):
        r"""calibrationError(CalibrationHelper self) -> Real"""
        return _QuantLib.CalibrationHelper_calibrationError(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationHelper

# Register CalibrationHelper in _QuantLib:
_QuantLib.CalibrationHelper_swigregister(CalibrationHelper)
class BlackCalibrationHelper(CalibrationHelper):
    r"""Proxy of C++ BlackCalibrationHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    RelativePriceError = _QuantLib.BlackCalibrationHelper_RelativePriceError
    
    PriceError = _QuantLib.BlackCalibrationHelper_PriceError
    
    ImpliedVolError = _QuantLib.BlackCalibrationHelper_ImpliedVolError
    

    def setPricingEngine(self, engine):
        r"""setPricingEngine(BlackCalibrationHelper self, ext::shared_ptr< PricingEngine > const & engine)"""
        return _QuantLib.BlackCalibrationHelper_setPricingEngine(self, engine)

    def marketValue(self):
        r"""marketValue(BlackCalibrationHelper self) -> Real"""
        return _QuantLib.BlackCalibrationHelper_marketValue(self)

    def modelValue(self):
        r"""modelValue(BlackCalibrationHelper self) -> Real"""
        return _QuantLib.BlackCalibrationHelper_modelValue(self)

    def impliedVolatility(self, targetValue, accuracy, maxEvaluations, minVol, maxVol):
        r"""impliedVolatility(BlackCalibrationHelper self, Real targetValue, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) -> Volatility"""
        return _QuantLib.BlackCalibrationHelper_impliedVolatility(self, targetValue, accuracy, maxEvaluations, minVol, maxVol)

    def blackPrice(self, volatility):
        r"""blackPrice(BlackCalibrationHelper self, Volatility volatility) -> Real"""
        return _QuantLib.BlackCalibrationHelper_blackPrice(self, volatility)

    def volatility(self):
        r"""volatility(BlackCalibrationHelper self) -> QuoteHandle"""
        return _QuantLib.BlackCalibrationHelper_volatility(self)

    def volatilityType(self):
        r"""volatilityType(BlackCalibrationHelper self) -> VolatilityType"""
        return _QuantLib.BlackCalibrationHelper_volatilityType(self)

    def calibrationError(self):
        r"""calibrationError(BlackCalibrationHelper self) -> Real"""
        return _QuantLib.BlackCalibrationHelper_calibrationError(self)
    __swig_destroy__ = _QuantLib.delete_BlackCalibrationHelper

# Register BlackCalibrationHelper in _QuantLib:
_QuantLib.BlackCalibrationHelper_swigregister(BlackCalibrationHelper)

def as_black_helper(h):
    r"""as_black_helper(ext::shared_ptr< CalibrationHelper > const & h) -> ext::shared_ptr< BlackCalibrationHelper >"""
    return _QuantLib.as_black_helper(h)

def as_swaption_helper(h):
    r"""as_swaption_helper(ext::shared_ptr< BlackCalibrationHelper > const & h) -> ext::shared_ptr< SwaptionHelper >"""
    return _QuantLib.as_swaption_helper(h)
class SwaptionHelper(BlackCalibrationHelper):
    r"""Proxy of C++ SwaptionHelper class."""

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

    def __init__(self, *args):
        r"""
        __init__(SwaptionHelper self, Period maturity, Period length, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, Real const strike=Null< Real >(), Real const nominal=1.0, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SwaptionHelper
        __init__(SwaptionHelper self, Date exerciseDate, Period length, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, Real const strike=Null< Real >(), Real const nominal=1.0, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SwaptionHelper
        __init__(SwaptionHelper self, Date exerciseDate, Date endDate, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, Real const strike=Null< Real >(), Real const nominal=1.0, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> SwaptionHelper
        """
        _QuantLib.SwaptionHelper_swiginit(self, _QuantLib.new_SwaptionHelper(*args))

    def underlyingSwap(self):
        r"""underlyingSwap(SwaptionHelper self) -> ext::shared_ptr< VanillaSwap >"""
        return _QuantLib.SwaptionHelper_underlyingSwap(self)

    def swaption(self):
        r"""swaption(SwaptionHelper self) -> ext::shared_ptr< Swaption >"""
        return _QuantLib.SwaptionHelper_swaption(self)

    def times(self):
        r"""times(SwaptionHelper self) -> DoubleVector"""
        return _QuantLib.SwaptionHelper_times(self)

    def swaptionExpiryDate(self):
        r"""swaptionExpiryDate(SwaptionHelper self) -> Date"""
        return _QuantLib.SwaptionHelper_swaptionExpiryDate(self)

    def swaptionStrike(self):
        r"""swaptionStrike(SwaptionHelper self) -> Real"""
        return _QuantLib.SwaptionHelper_swaptionStrike(self)

    def swaptionNominal(self):
        r"""swaptionNominal(SwaptionHelper self) -> Real"""
        return _QuantLib.SwaptionHelper_swaptionNominal(self)

    def swaptionMaturityDate(self):
        r"""swaptionMaturityDate(SwaptionHelper self) -> Date"""
        return _QuantLib.SwaptionHelper_swaptionMaturityDate(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionHelper

# Register SwaptionHelper in _QuantLib:
_QuantLib.SwaptionHelper_swigregister(SwaptionHelper)
class CapHelper(BlackCalibrationHelper):
    r"""Proxy of C++ CapHelper class."""

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

    def __init__(self, *args):
        r"""__init__(CapHelper self, Period length, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Frequency fixedLegFrequency, DayCounter fixedLegDayCounter, bool includeFirstSwaplet, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, VolatilityType const type=ShiftedLognormal, Real const shift=0.0) -> CapHelper"""
        _QuantLib.CapHelper_swiginit(self, _QuantLib.new_CapHelper(*args))

    def times(self):
        r"""times(CapHelper self) -> DoubleVector"""
        return _QuantLib.CapHelper_times(self)
    __swig_destroy__ = _QuantLib.delete_CapHelper

# Register CapHelper in _QuantLib:
_QuantLib.CapHelper_swigregister(CapHelper)
class HestonModelHelper(BlackCalibrationHelper):
    r"""Proxy of C++ HestonModelHelper class."""

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

    def __init__(self, *args):
        r"""__init__(HestonModelHelper self, Period maturity, Calendar calendar, Real const s0, Real const strikePrice, QuoteHandle volatility, YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError) -> HestonModelHelper"""
        _QuantLib.HestonModelHelper_swiginit(self, _QuantLib.new_HestonModelHelper(*args))
    __swig_destroy__ = _QuantLib.delete_HestonModelHelper

# Register HestonModelHelper in _QuantLib:
_QuantLib.HestonModelHelper_swigregister(HestonModelHelper)
class CalibrationHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< CalibrationHelper > > class."""

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

    def iterator(self):
        r"""iterator(CalibrationHelperVector self) -> SwigPyIterator"""
        return _QuantLib.CalibrationHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(CalibrationHelperVector self) -> bool"""
        return _QuantLib.CalibrationHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CalibrationHelperVector self) -> bool"""
        return _QuantLib.CalibrationHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::size_type"""
        return _QuantLib.CalibrationHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j) -> CalibrationHelperVector"""
        return _QuantLib.CalibrationHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j)
        __setslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j, CalibrationHelperVector v)
        """
        return _QuantLib.CalibrationHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j)"""
        return _QuantLib.CalibrationHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i)
        __delitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.CalibrationHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice) -> CalibrationHelperVector
        __getitem__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &
        """
        return _QuantLib.CalibrationHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice, CalibrationHelperVector v)
        __setitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)
        """
        return _QuantLib.CalibrationHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type"""
        return _QuantLib.CalibrationHelperVector_pop(self)

    def append(self, x):
        r"""append(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)"""
        return _QuantLib.CalibrationHelperVector_append(self, x)

    def empty(self):
        r"""empty(CalibrationHelperVector self) -> bool"""
        return _QuantLib.CalibrationHelperVector_empty(self)

    def size(self):
        r"""size(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::size_type"""
        return _QuantLib.CalibrationHelperVector_size(self)

    def swap(self, v):
        r"""swap(CalibrationHelperVector self, CalibrationHelperVector v)"""
        return _QuantLib.CalibrationHelperVector_swap(self, v)

    def begin(self):
        r"""begin(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator"""
        return _QuantLib.CalibrationHelperVector_begin(self)

    def end(self):
        r"""end(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator"""
        return _QuantLib.CalibrationHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator"""
        return _QuantLib.CalibrationHelperVector_rbegin(self)

    def rend(self):
        r"""rend(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator"""
        return _QuantLib.CalibrationHelperVector_rend(self)

    def clear(self):
        r"""clear(CalibrationHelperVector self)"""
        return _QuantLib.CalibrationHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::allocator_type"""
        return _QuantLib.CalibrationHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(CalibrationHelperVector self)"""
        return _QuantLib.CalibrationHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator
        erase(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator first, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator last) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator
        """
        return _QuantLib.CalibrationHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CalibrationHelperVector self) -> CalibrationHelperVector
        __init__(CalibrationHelperVector self, CalibrationHelperVector other) -> CalibrationHelperVector
        __init__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type size) -> CalibrationHelperVector
        __init__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type size, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & value) -> CalibrationHelperVector
        """
        _QuantLib.CalibrationHelperVector_swiginit(self, _QuantLib.new_CalibrationHelperVector(*args))

    def push_back(self, x):
        r"""push_back(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)"""
        return _QuantLib.CalibrationHelperVector_push_back(self, x)

    def front(self):
        r"""front(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &"""
        return _QuantLib.CalibrationHelperVector_front(self)

    def back(self):
        r"""back(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &"""
        return _QuantLib.CalibrationHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)"""
        return _QuantLib.CalibrationHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type new_size)
        resize(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type new_size, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)
        """
        return _QuantLib.CalibrationHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator
        insert(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)
        """
        return _QuantLib.CalibrationHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n)"""
        return _QuantLib.CalibrationHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::size_type"""
        return _QuantLib.CalibrationHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationHelperVector

# Register CalibrationHelperVector in _QuantLib:
_QuantLib.CalibrationHelperVector_swigregister(CalibrationHelperVector)
class BlackCalibrationHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< BlackCalibrationHelper > > class."""

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

    def iterator(self):
        r"""iterator(BlackCalibrationHelperVector self) -> SwigPyIterator"""
        return _QuantLib.BlackCalibrationHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(BlackCalibrationHelperVector self) -> bool"""
        return _QuantLib.BlackCalibrationHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(BlackCalibrationHelperVector self) -> bool"""
        return _QuantLib.BlackCalibrationHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type"""
        return _QuantLib.BlackCalibrationHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j) -> BlackCalibrationHelperVector"""
        return _QuantLib.BlackCalibrationHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j)
        __setslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j, BlackCalibrationHelperVector v)
        """
        return _QuantLib.BlackCalibrationHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j)"""
        return _QuantLib.BlackCalibrationHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i)
        __delitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.BlackCalibrationHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice) -> BlackCalibrationHelperVector
        __getitem__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &
        """
        return _QuantLib.BlackCalibrationHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice, BlackCalibrationHelperVector v)
        __setitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)
        """
        return _QuantLib.BlackCalibrationHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type"""
        return _QuantLib.BlackCalibrationHelperVector_pop(self)

    def append(self, x):
        r"""append(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)"""
        return _QuantLib.BlackCalibrationHelperVector_append(self, x)

    def empty(self):
        r"""empty(BlackCalibrationHelperVector self) -> bool"""
        return _QuantLib.BlackCalibrationHelperVector_empty(self)

    def size(self):
        r"""size(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type"""
        return _QuantLib.BlackCalibrationHelperVector_size(self)

    def swap(self, v):
        r"""swap(BlackCalibrationHelperVector self, BlackCalibrationHelperVector v)"""
        return _QuantLib.BlackCalibrationHelperVector_swap(self, v)

    def begin(self):
        r"""begin(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator"""
        return _QuantLib.BlackCalibrationHelperVector_begin(self)

    def end(self):
        r"""end(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator"""
        return _QuantLib.BlackCalibrationHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator"""
        return _QuantLib.BlackCalibrationHelperVector_rbegin(self)

    def rend(self):
        r"""rend(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator"""
        return _QuantLib.BlackCalibrationHelperVector_rend(self)

    def clear(self):
        r"""clear(BlackCalibrationHelperVector self)"""
        return _QuantLib.BlackCalibrationHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::allocator_type"""
        return _QuantLib.BlackCalibrationHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(BlackCalibrationHelperVector self)"""
        return _QuantLib.BlackCalibrationHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator
        erase(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator first, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator last) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator
        """
        return _QuantLib.BlackCalibrationHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(BlackCalibrationHelperVector self) -> BlackCalibrationHelperVector
        __init__(BlackCalibrationHelperVector self, BlackCalibrationHelperVector other) -> BlackCalibrationHelperVector
        __init__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type size) -> BlackCalibrationHelperVector
        __init__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type size, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & value) -> BlackCalibrationHelperVector
        """
        _QuantLib.BlackCalibrationHelperVector_swiginit(self, _QuantLib.new_BlackCalibrationHelperVector(*args))

    def push_back(self, x):
        r"""push_back(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)"""
        return _QuantLib.BlackCalibrationHelperVector_push_back(self, x)

    def front(self):
        r"""front(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &"""
        return _QuantLib.BlackCalibrationHelperVector_front(self)

    def back(self):
        r"""back(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &"""
        return _QuantLib.BlackCalibrationHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)"""
        return _QuantLib.BlackCalibrationHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type new_size)
        resize(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type new_size, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)
        """
        return _QuantLib.BlackCalibrationHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator
        insert(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)
        """
        return _QuantLib.BlackCalibrationHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n)"""
        return _QuantLib.BlackCalibrationHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type"""
        return _QuantLib.BlackCalibrationHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_BlackCalibrationHelperVector

# Register BlackCalibrationHelperVector in _QuantLib:
_QuantLib.BlackCalibrationHelperVector_swigregister(BlackCalibrationHelperVector)
class CalibratedModel(Observable):
    r"""Proxy of C++ CalibratedModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def params(self):
        r"""params(CalibratedModel self) -> Array"""
        return _QuantLib.CalibratedModel_params(self)

    def calibrate(self, *args):
        r"""calibrate(CalibratedModel self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"""
        return _QuantLib.CalibratedModel_calibrate(self, *args)

    def setParams(self, params):
        r"""setParams(CalibratedModel self, Array params)"""
        return _QuantLib.CalibratedModel_setParams(self, params)

    def value(self, params, arg3):
        r"""value(CalibratedModel self, Array params, CalibrationHelperVector arg3) -> Real"""
        return _QuantLib.CalibratedModel_value(self, params, arg3)

    def constraint(self):
        r"""constraint(CalibratedModel self) -> ext::shared_ptr< Constraint > const &"""
        return _QuantLib.CalibratedModel_constraint(self)

    def endCriteria(self):
        r"""endCriteria(CalibratedModel self) -> EndCriteria::Type"""
        return _QuantLib.CalibratedModel_endCriteria(self)

    def problemValues(self):
        r"""problemValues(CalibratedModel self) -> Array"""
        return _QuantLib.CalibratedModel_problemValues(self)

    def functionEvaluation(self):
        r"""functionEvaluation(CalibratedModel self) -> Integer"""
        return _QuantLib.CalibratedModel_functionEvaluation(self)
    __swig_destroy__ = _QuantLib.delete_CalibratedModel

# Register CalibratedModel in _QuantLib:
_QuantLib.CalibratedModel_swigregister(CalibratedModel)
class TermStructureConsistentModel(Observable):
    r"""Proxy of C++ TermStructureConsistentModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def termStructure(self):
        r"""termStructure(TermStructureConsistentModel self) -> YieldTermStructureHandle"""
        return _QuantLib.TermStructureConsistentModel_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_TermStructureConsistentModel

# Register TermStructureConsistentModel in _QuantLib:
_QuantLib.TermStructureConsistentModel_swigregister(TermStructureConsistentModel)
class CalibratedModelHandle(object):
    r"""Proxy of C++ Handle< CalibratedModel > class."""

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

    def __init__(self, *args):
        r"""__init__(CalibratedModelHandle self, ext::shared_ptr< CalibratedModel > const & arg2=ext::shared_ptr()) -> CalibratedModelHandle"""
        _QuantLib.CalibratedModelHandle_swiginit(self, _QuantLib.new_CalibratedModelHandle(*args))

    def __deref__(self):
        r"""__deref__(CalibratedModelHandle self) -> ext::shared_ptr< CalibratedModel >"""
        return _QuantLib.CalibratedModelHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(CalibratedModelHandle self) -> ext::shared_ptr< CalibratedModel >"""
        return _QuantLib.CalibratedModelHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(CalibratedModelHandle self) -> bool"""
        return _QuantLib.CalibratedModelHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CalibratedModelHandle self) -> bool"""
        return _QuantLib.CalibratedModelHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(CalibratedModelHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.CalibratedModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_CalibratedModelHandle

    def params(self):
        r"""params(CalibratedModelHandle self) -> Array"""
        return _QuantLib.CalibratedModelHandle_params(self)

    def calibrate(self, *args):
        r"""calibrate(CalibratedModelHandle self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"""
        return _QuantLib.CalibratedModelHandle_calibrate(self, *args)

    def setParams(self, params):
        r"""setParams(CalibratedModelHandle self, Array params)"""
        return _QuantLib.CalibratedModelHandle_setParams(self, params)

    def value(self, params, arg3):
        r"""value(CalibratedModelHandle self, Array params, CalibrationHelperVector arg3) -> Real"""
        return _QuantLib.CalibratedModelHandle_value(self, params, arg3)

    def constraint(self):
        r"""constraint(CalibratedModelHandle self) -> ext::shared_ptr< Constraint > const &"""
        return _QuantLib.CalibratedModelHandle_constraint(self)

    def endCriteria(self):
        r"""endCriteria(CalibratedModelHandle self) -> EndCriteria::Type"""
        return _QuantLib.CalibratedModelHandle_endCriteria(self)

    def problemValues(self):
        r"""problemValues(CalibratedModelHandle self) -> Array"""
        return _QuantLib.CalibratedModelHandle_problemValues(self)

    def functionEvaluation(self):
        r"""functionEvaluation(CalibratedModelHandle self) -> Integer"""
        return _QuantLib.CalibratedModelHandle_functionEvaluation(self)

# Register CalibratedModelHandle in _QuantLib:
_QuantLib.CalibratedModelHandle_swigregister(CalibratedModelHandle)
class RelinkableCalibratedModelHandle(CalibratedModelHandle):
    r"""Proxy of C++ RelinkableHandle< CalibratedModel > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableCalibratedModelHandle self, ext::shared_ptr< CalibratedModel > const & arg2=ext::shared_ptr()) -> RelinkableCalibratedModelHandle"""
        _QuantLib.RelinkableCalibratedModelHandle_swiginit(self, _QuantLib.new_RelinkableCalibratedModelHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableCalibratedModelHandle self, ext::shared_ptr< CalibratedModel > const & arg2)"""
        return _QuantLib.RelinkableCalibratedModelHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableCalibratedModelHandle self)"""
        return _QuantLib.RelinkableCalibratedModelHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableCalibratedModelHandle

# Register RelinkableCalibratedModelHandle in _QuantLib:
_QuantLib.RelinkableCalibratedModelHandle_swigregister(RelinkableCalibratedModelHandle)
class TimeGrid(object):
    r"""Proxy of C++ TimeGrid class."""

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

    def __init__(self, *args):
        r"""
        __init__(TimeGrid self) -> TimeGrid
        __init__(TimeGrid self, Time end, Size steps) -> TimeGrid
        __init__(TimeGrid self, DoubleVector times) -> TimeGrid
        __init__(TimeGrid self, DoubleVector times, Size steps) -> TimeGrid
        """
        _QuantLib.TimeGrid_swiginit(self, _QuantLib.new_TimeGrid(*args))

    def __len__(self):
        r"""__len__(TimeGrid self) -> Size"""
        return _QuantLib.TimeGrid___len__(self)

    def __getitem__(self, i):
        r"""__getitem__(TimeGrid self, Integer i) -> Time"""
        return _QuantLib.TimeGrid___getitem__(self, i)

    def dt(self, i):
        r"""dt(TimeGrid self, Integer i) -> Time"""
        return _QuantLib.TimeGrid_dt(self, i)
    __swig_destroy__ = _QuantLib.delete_TimeGrid

# Register TimeGrid in _QuantLib:
_QuantLib.TimeGrid_swigregister(TimeGrid)
class Parameter(object):
    r"""Proxy of C++ Parameter class."""

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

    def __init__(self):
        r"""__init__(Parameter self) -> Parameter"""
        _QuantLib.Parameter_swiginit(self, _QuantLib.new_Parameter())

    def params(self):
        r"""params(Parameter self) -> Array"""
        return _QuantLib.Parameter_params(self)

    def setParam(self, i, x):
        r"""setParam(Parameter self, Size i, Real x)"""
        return _QuantLib.Parameter_setParam(self, i, x)

    def testParams(self, params):
        r"""testParams(Parameter self, Array params) -> bool"""
        return _QuantLib.Parameter_testParams(self, params)

    def size(self):
        r"""size(Parameter self) -> Size"""
        return _QuantLib.Parameter_size(self)

    def __call__(self, t):
        r"""__call__(Parameter self, Time t) -> Real"""
        return _QuantLib.Parameter___call__(self, t)

    def constraint(self):
        r"""constraint(Parameter self) -> Constraint"""
        return _QuantLib.Parameter_constraint(self)
    __swig_destroy__ = _QuantLib.delete_Parameter

# Register Parameter in _QuantLib:
_QuantLib.Parameter_swigregister(Parameter)
class ConstantParameter(Parameter):
    r"""Proxy of C++ ConstantParameter class."""

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

    def __init__(self, *args):
        r"""
        __init__(ConstantParameter self, Constraint constraint) -> ConstantParameter
        __init__(ConstantParameter self, Real value, Constraint constraint) -> ConstantParameter
        """
        _QuantLib.ConstantParameter_swiginit(self, _QuantLib.new_ConstantParameter(*args))
    __swig_destroy__ = _QuantLib.delete_ConstantParameter

# Register ConstantParameter in _QuantLib:
_QuantLib.ConstantParameter_swigregister(ConstantParameter)
class NullParameter(Parameter):
    r"""Proxy of C++ NullParameter class."""

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

    def __init__(self):
        r"""__init__(NullParameter self) -> NullParameter"""
        _QuantLib.NullParameter_swiginit(self, _QuantLib.new_NullParameter())
    __swig_destroy__ = _QuantLib.delete_NullParameter

# Register NullParameter in _QuantLib:
_QuantLib.NullParameter_swigregister(NullParameter)
class PiecewiseConstantParameter(Parameter):
    r"""Proxy of C++ PiecewiseConstantParameter class."""

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

    def __init__(self, *args):
        r"""__init__(PiecewiseConstantParameter self, DoubleVector times, Constraint constraint=QuantLib::NoConstraint()) -> PiecewiseConstantParameter"""
        _QuantLib.PiecewiseConstantParameter_swiginit(self, _QuantLib.new_PiecewiseConstantParameter(*args))
    __swig_destroy__ = _QuantLib.delete_PiecewiseConstantParameter

# Register PiecewiseConstantParameter in _QuantLib:
_QuantLib.PiecewiseConstantParameter_swigregister(PiecewiseConstantParameter)
class Payoff(object):
    r"""Proxy of C++ Payoff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __call__(self, price):
        r"""__call__(Payoff self, Real price) -> Real"""
        return _QuantLib.Payoff___call__(self, price)
    __swig_destroy__ = _QuantLib.delete_Payoff

# Register Payoff in _QuantLib:
_QuantLib.Payoff_swigregister(Payoff)
class Option(Instrument):
    r"""Proxy of C++ Option class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Put = _QuantLib.Option_Put
    
    Call = _QuantLib.Option_Call
    

    def payoff(self):
        r"""payoff(Option self) -> ext::shared_ptr< Payoff >"""
        return _QuantLib.Option_payoff(self)

    def exercise(self):
        r"""exercise(Option self) -> ext::shared_ptr< Exercise >"""
        return _QuantLib.Option_exercise(self)
    __swig_destroy__ = _QuantLib.delete_Option

# Register Option in _QuantLib:
_QuantLib.Option_swigregister(Option)
class TypePayoff(Payoff):
    r"""Proxy of C++ TypePayoff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def optionType(self):
        r"""optionType(TypePayoff self) -> Option::Type"""
        return _QuantLib.TypePayoff_optionType(self)
    __swig_destroy__ = _QuantLib.delete_TypePayoff

# Register TypePayoff in _QuantLib:
_QuantLib.TypePayoff_swigregister(TypePayoff)
class FloatingTypePayoff(TypePayoff):
    r"""Proxy of C++ FloatingTypePayoff class."""

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

    def __init__(self, type):
        r"""__init__(FloatingTypePayoff self, Option::Type type) -> FloatingTypePayoff"""
        _QuantLib.FloatingTypePayoff_swiginit(self, _QuantLib.new_FloatingTypePayoff(type))

    def __call__(self, *args):
        r"""
        __call__(FloatingTypePayoff self, Real price, Real strike) -> Real
        __call__(FloatingTypePayoff self, Real price) -> Real
        """
        return _QuantLib.FloatingTypePayoff___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_FloatingTypePayoff

# Register FloatingTypePayoff in _QuantLib:
_QuantLib.FloatingTypePayoff_swigregister(FloatingTypePayoff)
class StrikedTypePayoff(TypePayoff):
    r"""Proxy of C++ StrikedTypePayoff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def strike(self):
        r"""strike(StrikedTypePayoff self) -> Real"""
        return _QuantLib.StrikedTypePayoff_strike(self)
    __swig_destroy__ = _QuantLib.delete_StrikedTypePayoff

# Register StrikedTypePayoff in _QuantLib:
_QuantLib.StrikedTypePayoff_swigregister(StrikedTypePayoff)
class DeltaVolQuote(Quote):
    r"""Proxy of C++ DeltaVolQuote class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Spot = _QuantLib.DeltaVolQuote_Spot
    
    Fwd = _QuantLib.DeltaVolQuote_Fwd
    
    PaSpot = _QuantLib.DeltaVolQuote_PaSpot
    
    PaFwd = _QuantLib.DeltaVolQuote_PaFwd
    
    AtmNull = _QuantLib.DeltaVolQuote_AtmNull
    
    AtmSpot = _QuantLib.DeltaVolQuote_AtmSpot
    
    AtmFwd = _QuantLib.DeltaVolQuote_AtmFwd
    
    AtmDeltaNeutral = _QuantLib.DeltaVolQuote_AtmDeltaNeutral
    
    AtmVegaMax = _QuantLib.DeltaVolQuote_AtmVegaMax
    
    AtmGammaMax = _QuantLib.DeltaVolQuote_AtmGammaMax
    
    AtmPutCall50 = _QuantLib.DeltaVolQuote_AtmPutCall50
    

    def __init__(self, *args):
        r"""
        __init__(DeltaVolQuote self, Real delta, QuoteHandle vol, Time maturity, DeltaVolQuote::DeltaType deltaType) -> DeltaVolQuote
        __init__(DeltaVolQuote self, QuoteHandle vol, DeltaVolQuote::DeltaType deltaType, Time maturity, DeltaVolQuote::AtmType atmType) -> DeltaVolQuote
        """
        _QuantLib.DeltaVolQuote_swiginit(self, _QuantLib.new_DeltaVolQuote(*args))

    def delta(self):
        r"""delta(DeltaVolQuote self) -> Real"""
        return _QuantLib.DeltaVolQuote_delta(self)

    def maturity(self):
        r"""maturity(DeltaVolQuote self) -> Time"""
        return _QuantLib.DeltaVolQuote_maturity(self)

    def atmType(self):
        r"""atmType(DeltaVolQuote self) -> DeltaVolQuote::AtmType"""
        return _QuantLib.DeltaVolQuote_atmType(self)

    def deltaType(self):
        r"""deltaType(DeltaVolQuote self) -> DeltaVolQuote::DeltaType"""
        return _QuantLib.DeltaVolQuote_deltaType(self)
    __swig_destroy__ = _QuantLib.delete_DeltaVolQuote

# Register DeltaVolQuote in _QuantLib:
_QuantLib.DeltaVolQuote_swigregister(DeltaVolQuote)
class DeltaVolQuoteHandle(object):
    r"""Proxy of C++ Handle< DeltaVolQuote > class."""

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

    def __init__(self, *args):
        r"""__init__(DeltaVolQuoteHandle self, ext::shared_ptr< DeltaVolQuote > const & arg2=ext::shared_ptr()) -> DeltaVolQuoteHandle"""
        _QuantLib.DeltaVolQuoteHandle_swiginit(self, _QuantLib.new_DeltaVolQuoteHandle(*args))

    def __deref__(self):
        r"""__deref__(DeltaVolQuoteHandle self) -> ext::shared_ptr< DeltaVolQuote >"""
        return _QuantLib.DeltaVolQuoteHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(DeltaVolQuoteHandle self) -> ext::shared_ptr< DeltaVolQuote >"""
        return _QuantLib.DeltaVolQuoteHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(DeltaVolQuoteHandle self) -> bool"""
        return _QuantLib.DeltaVolQuoteHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DeltaVolQuoteHandle self) -> bool"""
        return _QuantLib.DeltaVolQuoteHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(DeltaVolQuoteHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.DeltaVolQuoteHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_DeltaVolQuoteHandle

    def delta(self):
        r"""delta(DeltaVolQuoteHandle self) -> Real"""
        return _QuantLib.DeltaVolQuoteHandle_delta(self)

    def maturity(self):
        r"""maturity(DeltaVolQuoteHandle self) -> Time"""
        return _QuantLib.DeltaVolQuoteHandle_maturity(self)

    def atmType(self):
        r"""atmType(DeltaVolQuoteHandle self) -> DeltaVolQuote::AtmType"""
        return _QuantLib.DeltaVolQuoteHandle_atmType(self)

    def deltaType(self):
        r"""deltaType(DeltaVolQuoteHandle self) -> DeltaVolQuote::DeltaType"""
        return _QuantLib.DeltaVolQuoteHandle_deltaType(self)

    def value(self):
        r"""value(DeltaVolQuoteHandle self) -> Real"""
        return _QuantLib.DeltaVolQuoteHandle_value(self)

    def isValid(self):
        r"""isValid(DeltaVolQuoteHandle self) -> bool"""
        return _QuantLib.DeltaVolQuoteHandle_isValid(self)

# Register DeltaVolQuoteHandle in _QuantLib:
_QuantLib.DeltaVolQuoteHandle_swigregister(DeltaVolQuoteHandle)
class RelinkableDeltaVolQuoteHandle(DeltaVolQuoteHandle):
    r"""Proxy of C++ RelinkableHandle< DeltaVolQuote > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableDeltaVolQuoteHandle self, ext::shared_ptr< DeltaVolQuote > const & arg2=ext::shared_ptr()) -> RelinkableDeltaVolQuoteHandle"""
        _QuantLib.RelinkableDeltaVolQuoteHandle_swiginit(self, _QuantLib.new_RelinkableDeltaVolQuoteHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableDeltaVolQuoteHandle self, ext::shared_ptr< DeltaVolQuote > const & arg2)"""
        return _QuantLib.RelinkableDeltaVolQuoteHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableDeltaVolQuoteHandle self)"""
        return _QuantLib.RelinkableDeltaVolQuoteHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableDeltaVolQuoteHandle

# Register RelinkableDeltaVolQuoteHandle in _QuantLib:
_QuantLib.RelinkableDeltaVolQuoteHandle_swigregister(RelinkableDeltaVolQuoteHandle)
class OneAssetOption(Option):
    r"""Proxy of C++ OneAssetOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def delta(self):
        r"""delta(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_delta(self)

    def deltaForward(self):
        r"""deltaForward(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_deltaForward(self)

    def elasticity(self):
        r"""elasticity(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_elasticity(self)

    def gamma(self):
        r"""gamma(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_gamma(self)

    def theta(self):
        r"""theta(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_theta(self)

    def thetaPerDay(self):
        r"""thetaPerDay(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_thetaPerDay(self)

    def vega(self):
        r"""vega(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_vega(self)

    def rho(self):
        r"""rho(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_rho(self)

    def dividendRho(self):
        r"""dividendRho(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_dividendRho(self)

    def strikeSensitivity(self):
        r"""strikeSensitivity(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_strikeSensitivity(self)

    def itmCashProbability(self):
        r"""itmCashProbability(OneAssetOption self) -> Real"""
        return _QuantLib.OneAssetOption_itmCashProbability(self)
    __swig_destroy__ = _QuantLib.delete_OneAssetOption

# Register OneAssetOption in _QuantLib:
_QuantLib.OneAssetOption_swigregister(OneAssetOption)
class VanillaOption(OneAssetOption):
    r"""Proxy of C++ VanillaOption class."""

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

    def __init__(self, payoff, exercise):
        r"""__init__(VanillaOption self, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> VanillaOption"""
        _QuantLib.VanillaOption_swiginit(self, _QuantLib.new_VanillaOption(payoff, exercise))

    def impliedVolatility(self, targetValue, process, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-4, maxVol=4.0):
        r"""impliedVolatility(VanillaOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility"""
        return _QuantLib.VanillaOption_impliedVolatility(self, targetValue, process, accuracy, maxEvaluations, minVol, maxVol)

    def priceCurve(self):
        r"""priceCurve(VanillaOption self) -> SampledCurve"""
        return _QuantLib.VanillaOption_priceCurve(self)
    __swig_destroy__ = _QuantLib.delete_VanillaOption

# Register VanillaOption in _QuantLib:
_QuantLib.VanillaOption_swigregister(VanillaOption)
class CalibrationPair(object):
    r"""Proxy of C++ std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(CalibrationPair self) -> CalibrationPair
        __init__(CalibrationPair self, ext::shared_ptr< VanillaOption > first, ext::shared_ptr< Quote > second) -> CalibrationPair
        __init__(CalibrationPair self, CalibrationPair other) -> CalibrationPair
        """
        _QuantLib.CalibrationPair_swiginit(self, _QuantLib.new_CalibrationPair(*args))
    first = property(_QuantLib.CalibrationPair_first_get, _QuantLib.CalibrationPair_first_set, doc=r"""first : ext::shared_ptr<(VanillaOption)>""")
    second = property(_QuantLib.CalibrationPair_second_get, _QuantLib.CalibrationPair_second_set, doc=r"""second : ext::shared_ptr<(Quote)>""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _QuantLib.delete_CalibrationPair

# Register CalibrationPair in _QuantLib:
_QuantLib.CalibrationPair_swigregister(CalibrationPair)
class CalibrationSet(object):
    r"""Proxy of C++ std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > class."""

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

    def iterator(self):
        r"""iterator(CalibrationSet self) -> SwigPyIterator"""
        return _QuantLib.CalibrationSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(CalibrationSet self) -> bool"""
        return _QuantLib.CalibrationSet___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CalibrationSet self) -> bool"""
        return _QuantLib.CalibrationSet___bool__(self)

    def __len__(self):
        r"""__len__(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type"""
        return _QuantLib.CalibrationSet___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j) -> CalibrationSet"""
        return _QuantLib.CalibrationSet___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j)
        __setslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j, CalibrationSet v)
        """
        return _QuantLib.CalibrationSet___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j)"""
        return _QuantLib.CalibrationSet___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i)
        __delitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.CalibrationSet___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice) -> CalibrationSet
        __getitem__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i) -> CalibrationPair
        """
        return _QuantLib.CalibrationSet___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice, CalibrationSet v)
        __setitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, CalibrationPair x)
        """
        return _QuantLib.CalibrationSet___setitem__(self, *args)

    def pop(self):
        r"""pop(CalibrationSet self) -> CalibrationPair"""
        return _QuantLib.CalibrationSet_pop(self)

    def append(self, x):
        r"""append(CalibrationSet self, CalibrationPair x)"""
        return _QuantLib.CalibrationSet_append(self, x)

    def empty(self):
        r"""empty(CalibrationSet self) -> bool"""
        return _QuantLib.CalibrationSet_empty(self)

    def size(self):
        r"""size(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type"""
        return _QuantLib.CalibrationSet_size(self)

    def swap(self, v):
        r"""swap(CalibrationSet self, CalibrationSet v)"""
        return _QuantLib.CalibrationSet_swap(self, v)

    def begin(self):
        r"""begin(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator"""
        return _QuantLib.CalibrationSet_begin(self)

    def end(self):
        r"""end(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator"""
        return _QuantLib.CalibrationSet_end(self)

    def rbegin(self):
        r"""rbegin(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator"""
        return _QuantLib.CalibrationSet_rbegin(self)

    def rend(self):
        r"""rend(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator"""
        return _QuantLib.CalibrationSet_rend(self)

    def clear(self):
        r"""clear(CalibrationSet self)"""
        return _QuantLib.CalibrationSet_clear(self)

    def get_allocator(self):
        r"""get_allocator(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::allocator_type"""
        return _QuantLib.CalibrationSet_get_allocator(self)

    def pop_back(self):
        r"""pop_back(CalibrationSet self)"""
        return _QuantLib.CalibrationSet_pop_back(self)

    def erase(self, *args):
        r"""
        erase(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator
        erase(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator first, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator last) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator
        """
        return _QuantLib.CalibrationSet_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CalibrationSet self) -> CalibrationSet
        __init__(CalibrationSet self, CalibrationSet other) -> CalibrationSet
        __init__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type size) -> CalibrationSet
        __init__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type size, CalibrationPair value) -> CalibrationSet
        """
        _QuantLib.CalibrationSet_swiginit(self, _QuantLib.new_CalibrationSet(*args))

    def push_back(self, x):
        r"""push_back(CalibrationSet self, CalibrationPair x)"""
        return _QuantLib.CalibrationSet_push_back(self, x)

    def front(self):
        r"""front(CalibrationSet self) -> CalibrationPair"""
        return _QuantLib.CalibrationSet_front(self)

    def back(self):
        r"""back(CalibrationSet self) -> CalibrationPair"""
        return _QuantLib.CalibrationSet_back(self)

    def assign(self, n, x):
        r"""assign(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n, CalibrationPair x)"""
        return _QuantLib.CalibrationSet_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type new_size)
        resize(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type new_size, CalibrationPair x)
        """
        return _QuantLib.CalibrationSet_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos, CalibrationPair x) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator
        insert(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n, CalibrationPair x)
        """
        return _QuantLib.CalibrationSet_insert(self, *args)

    def reserve(self, n):
        r"""reserve(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n)"""
        return _QuantLib.CalibrationSet_reserve(self, n)

    def capacity(self):
        r"""capacity(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type"""
        return _QuantLib.CalibrationSet_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationSet

# Register CalibrationSet in _QuantLib:
_QuantLib.CalibrationSet_swigregister(CalibrationSet)
class EuropeanOption(VanillaOption):
    r"""Proxy of C++ EuropeanOption class."""

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

    def __init__(self, payoff, exercise):
        r"""__init__(EuropeanOption self, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> EuropeanOption"""
        _QuantLib.EuropeanOption_swiginit(self, _QuantLib.new_EuropeanOption(payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_EuropeanOption

# Register EuropeanOption in _QuantLib:
_QuantLib.EuropeanOption_swigregister(EuropeanOption)
class ForwardVanillaOption(OneAssetOption):
    r"""Proxy of C++ ForwardVanillaOption class."""

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

    def __init__(self, moneyness, resetDate, payoff, exercise):
        r"""__init__(ForwardVanillaOption self, Real moneyness, Date resetDate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ForwardVanillaOption"""
        _QuantLib.ForwardVanillaOption_swiginit(self, _QuantLib.new_ForwardVanillaOption(moneyness, resetDate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ForwardVanillaOption

# Register ForwardVanillaOption in _QuantLib:
_QuantLib.ForwardVanillaOption_swigregister(ForwardVanillaOption)
class QuantoVanillaOption(OneAssetOption):
    r"""Proxy of C++ QuantoVanillaOption class."""

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

    def __init__(self, payoff, exercise):
        r"""__init__(QuantoVanillaOption self, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoVanillaOption"""
        _QuantLib.QuantoVanillaOption_swiginit(self, _QuantLib.new_QuantoVanillaOption(payoff, exercise))

    def qvega(self):
        r"""qvega(QuantoVanillaOption self) -> Real"""
        return _QuantLib.QuantoVanillaOption_qvega(self)

    def qrho(self):
        r"""qrho(QuantoVanillaOption self) -> Real"""
        return _QuantLib.QuantoVanillaOption_qrho(self)

    def qlambda(self):
        r"""qlambda(QuantoVanillaOption self) -> Real"""
        return _QuantLib.QuantoVanillaOption_qlambda(self)
    __swig_destroy__ = _QuantLib.delete_QuantoVanillaOption

# Register QuantoVanillaOption in _QuantLib:
_QuantLib.QuantoVanillaOption_swigregister(QuantoVanillaOption)
class QuantoForwardVanillaOption(ForwardVanillaOption):
    r"""Proxy of C++ QuantoForwardVanillaOption class."""

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

    def __init__(self, moneyness, resetDate, payoff, exercise):
        r"""__init__(QuantoForwardVanillaOption self, Real moneyness, Date resetDate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoForwardVanillaOption"""
        _QuantLib.QuantoForwardVanillaOption_swiginit(self, _QuantLib.new_QuantoForwardVanillaOption(moneyness, resetDate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_QuantoForwardVanillaOption

# Register QuantoForwardVanillaOption in _QuantLib:
_QuantLib.QuantoForwardVanillaOption_swigregister(QuantoForwardVanillaOption)
class MultiAssetOption(Option):
    r"""Proxy of C++ MultiAssetOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def delta(self):
        r"""delta(MultiAssetOption self) -> Real"""
        return _QuantLib.MultiAssetOption_delta(self)

    def gamma(self):
        r"""gamma(MultiAssetOption self) -> Real"""
        return _QuantLib.MultiAssetOption_gamma(self)

    def theta(self):
        r"""theta(MultiAssetOption self) -> Real"""
        return _QuantLib.MultiAssetOption_theta(self)

    def vega(self):
        r"""vega(MultiAssetOption self) -> Real"""
        return _QuantLib.MultiAssetOption_vega(self)

    def rho(self):
        r"""rho(MultiAssetOption self) -> Real"""
        return _QuantLib.MultiAssetOption_rho(self)

    def dividendRho(self):
        r"""dividendRho(MultiAssetOption self) -> Real"""
        return _QuantLib.MultiAssetOption_dividendRho(self)
    __swig_destroy__ = _QuantLib.delete_MultiAssetOption

# Register MultiAssetOption in _QuantLib:
_QuantLib.MultiAssetOption_swigregister(MultiAssetOption)
class AnalyticEuropeanEngine(PricingEngine):
    r"""Proxy of C++ AnalyticEuropeanEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(AnalyticEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticEuropeanEngine
        __init__(AnalyticEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, YieldTermStructureHandle discountCurve) -> AnalyticEuropeanEngine
        """
        _QuantLib.AnalyticEuropeanEngine_swiginit(self, _QuantLib.new_AnalyticEuropeanEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticEuropeanEngine

# Register AnalyticEuropeanEngine in _QuantLib:
_QuantLib.AnalyticEuropeanEngine_swigregister(AnalyticEuropeanEngine)
class HestonModel(CalibratedModel):
    r"""Proxy of C++ HestonModel class."""

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

    def __init__(self, process):
        r"""__init__(HestonModel self, ext::shared_ptr< HestonProcess > const & process) -> HestonModel"""
        _QuantLib.HestonModel_swiginit(self, _QuantLib.new_HestonModel(process))

    def theta(self):
        r"""theta(HestonModel self) -> Real"""
        return _QuantLib.HestonModel_theta(self)

    def kappa(self):
        r"""kappa(HestonModel self) -> Real"""
        return _QuantLib.HestonModel_kappa(self)

    def sigma(self):
        r"""sigma(HestonModel self) -> Real"""
        return _QuantLib.HestonModel_sigma(self)

    def rho(self):
        r"""rho(HestonModel self) -> Real"""
        return _QuantLib.HestonModel_rho(self)

    def v0(self):
        r"""v0(HestonModel self) -> Real"""
        return _QuantLib.HestonModel_v0(self)
    __swig_destroy__ = _QuantLib.delete_HestonModel

# Register HestonModel in _QuantLib:
_QuantLib.HestonModel_swigregister(HestonModel)
class HestonModelHandle(object):
    r"""Proxy of C++ Handle< HestonModel > class."""

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

    def __init__(self, *args):
        r"""__init__(HestonModelHandle self, ext::shared_ptr< HestonModel > const & arg2=ext::shared_ptr()) -> HestonModelHandle"""
        _QuantLib.HestonModelHandle_swiginit(self, _QuantLib.new_HestonModelHandle(*args))

    def __deref__(self):
        r"""__deref__(HestonModelHandle self) -> ext::shared_ptr< HestonModel >"""
        return _QuantLib.HestonModelHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(HestonModelHandle self) -> ext::shared_ptr< HestonModel >"""
        return _QuantLib.HestonModelHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(HestonModelHandle self) -> bool"""
        return _QuantLib.HestonModelHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(HestonModelHandle self) -> bool"""
        return _QuantLib.HestonModelHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(HestonModelHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.HestonModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_HestonModelHandle

    def theta(self):
        r"""theta(HestonModelHandle self) -> Real"""
        return _QuantLib.HestonModelHandle_theta(self)

    def kappa(self):
        r"""kappa(HestonModelHandle self) -> Real"""
        return _QuantLib.HestonModelHandle_kappa(self)

    def sigma(self):
        r"""sigma(HestonModelHandle self) -> Real"""
        return _QuantLib.HestonModelHandle_sigma(self)

    def rho(self):
        r"""rho(HestonModelHandle self) -> Real"""
        return _QuantLib.HestonModelHandle_rho(self)

    def v0(self):
        r"""v0(HestonModelHandle self) -> Real"""
        return _QuantLib.HestonModelHandle_v0(self)

    def params(self):
        r"""params(HestonModelHandle self) -> Array"""
        return _QuantLib.HestonModelHandle_params(self)

    def calibrate(self, *args):
        r"""calibrate(HestonModelHandle self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"""
        return _QuantLib.HestonModelHandle_calibrate(self, *args)

    def setParams(self, params):
        r"""setParams(HestonModelHandle self, Array params)"""
        return _QuantLib.HestonModelHandle_setParams(self, params)

    def value(self, params, arg3):
        r"""value(HestonModelHandle self, Array params, CalibrationHelperVector arg3) -> Real"""
        return _QuantLib.HestonModelHandle_value(self, params, arg3)

    def constraint(self):
        r"""constraint(HestonModelHandle self) -> ext::shared_ptr< Constraint > const &"""
        return _QuantLib.HestonModelHandle_constraint(self)

    def endCriteria(self):
        r"""endCriteria(HestonModelHandle self) -> EndCriteria::Type"""
        return _QuantLib.HestonModelHandle_endCriteria(self)

    def problemValues(self):
        r"""problemValues(HestonModelHandle self) -> Array"""
        return _QuantLib.HestonModelHandle_problemValues(self)

    def functionEvaluation(self):
        r"""functionEvaluation(HestonModelHandle self) -> Integer"""
        return _QuantLib.HestonModelHandle_functionEvaluation(self)

# Register HestonModelHandle in _QuantLib:
_QuantLib.HestonModelHandle_swigregister(HestonModelHandle)
class PiecewiseTimeDependentHestonModel(CalibratedModel):
    r"""Proxy of C++ PiecewiseTimeDependentHestonModel class."""

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

    def __init__(self, riskFreeRate, dividendYield, s0, v0, theta, kappa, sigma, rho, timeGrid):
        r"""__init__(PiecewiseTimeDependentHestonModel self, YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, QuoteHandle s0, Real v0, Parameter theta, Parameter kappa, Parameter sigma, Parameter rho, TimeGrid timeGrid) -> PiecewiseTimeDependentHestonModel"""
        _QuantLib.PiecewiseTimeDependentHestonModel_swiginit(self, _QuantLib.new_PiecewiseTimeDependentHestonModel(riskFreeRate, dividendYield, s0, v0, theta, kappa, sigma, rho, timeGrid))

    def theta(self, t):
        r"""theta(PiecewiseTimeDependentHestonModel self, Time t) -> Real"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_theta(self, t)

    def kappa(self, t):
        r"""kappa(PiecewiseTimeDependentHestonModel self, Time t) -> Real"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_kappa(self, t)

    def sigma(self, t):
        r"""sigma(PiecewiseTimeDependentHestonModel self, Time t) -> Real"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_sigma(self, t)

    def rho(self, t):
        r"""rho(PiecewiseTimeDependentHestonModel self, Time t) -> Real"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_rho(self, t)

    def v0(self):
        r"""v0(PiecewiseTimeDependentHestonModel self) -> Real"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_v0(self)

    def s0(self):
        r"""s0(PiecewiseTimeDependentHestonModel self) -> Real"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_s0(self)

    def timeGrid(self):
        r"""timeGrid(PiecewiseTimeDependentHestonModel self) -> TimeGrid"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_timeGrid(self)

    def dividendYield(self):
        r"""dividendYield(PiecewiseTimeDependentHestonModel self) -> YieldTermStructureHandle"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_dividendYield(self)

    def riskFreeRate(self):
        r"""riskFreeRate(PiecewiseTimeDependentHestonModel self) -> YieldTermStructureHandle"""
        return _QuantLib.PiecewiseTimeDependentHestonModel_riskFreeRate(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseTimeDependentHestonModel

# Register PiecewiseTimeDependentHestonModel in _QuantLib:
_QuantLib.PiecewiseTimeDependentHestonModel_swigregister(PiecewiseTimeDependentHestonModel)
class AnalyticHestonEngine(PricingEngine):
    r"""Proxy of C++ AnalyticHestonEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Gatheral = _QuantLib.AnalyticHestonEngine_Gatheral
    
    BranchCorrection = _QuantLib.AnalyticHestonEngine_BranchCorrection
    
    AndersenPiterbarg = _QuantLib.AnalyticHestonEngine_AndersenPiterbarg
    
    AndersenPiterbargOptCV = _QuantLib.AnalyticHestonEngine_AndersenPiterbargOptCV
    
    AsymptoticChF = _QuantLib.AnalyticHestonEngine_AsymptoticChF
    
    OptimalCV = _QuantLib.AnalyticHestonEngine_OptimalCV
    

    def __init__(self, *args):
        r"""
        __init__(AnalyticHestonEngine self, ext::shared_ptr< HestonModel > const & model, Size integrationOrder=144) -> AnalyticHestonEngine
        __init__(AnalyticHestonEngine self, ext::shared_ptr< HestonModel > const & model, Real relTolerance, Size maxEvaluations) -> AnalyticHestonEngine
        __init__(AnalyticHestonEngine self, ext::shared_ptr< HestonModel > const & model, AnalyticHestonEngine::ComplexLogFormula cpxLog, AnalyticHestonEngine_Integration itg, Real andersenPiterbargEpsilon=1e-8) -> AnalyticHestonEngine
        """
        _QuantLib.AnalyticHestonEngine_swiginit(self, _QuantLib.new_AnalyticHestonEngine(*args))

    def chF(self, real, imag, t):
        r"""chF(AnalyticHestonEngine self, Real real, Real imag, Time t) -> DoublePair"""
        return _QuantLib.AnalyticHestonEngine_chF(self, real, imag, t)
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonEngine

# Register AnalyticHestonEngine in _QuantLib:
_QuantLib.AnalyticHestonEngine_swigregister(AnalyticHestonEngine)
class AnalyticHestonEngine_Integration(object):
    r"""Proxy of C++ AnalyticHestonEngine::Integration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def gaussLaguerre(integrationOrder=128):
        r"""gaussLaguerre(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_gaussLaguerre(integrationOrder)

    @staticmethod
    def gaussLegendre(integrationOrder=128):
        r"""gaussLegendre(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_gaussLegendre(integrationOrder)

    @staticmethod
    def gaussChebyshev(integrationOrder=128):
        r"""gaussChebyshev(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_gaussChebyshev(integrationOrder)

    @staticmethod
    def gaussChebyshev2nd(integrationOrder=128):
        r"""gaussChebyshev2nd(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_gaussChebyshev2nd(integrationOrder)

    @staticmethod
    def gaussLobatto(relTolerance, absTolerance, maxEvaluations=1000):
        r"""gaussLobatto(Real relTolerance, Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_gaussLobatto(relTolerance, absTolerance, maxEvaluations)

    @staticmethod
    def gaussKronrod(absTolerance, maxEvaluations=1000):
        r"""gaussKronrod(Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_gaussKronrod(absTolerance, maxEvaluations)

    @staticmethod
    def simpson(absTolerance, maxEvaluations=1000):
        r"""simpson(Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_simpson(absTolerance, maxEvaluations)

    @staticmethod
    def trapezoid(absTolerance, maxEvaluations=1000):
        r"""trapezoid(Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_trapezoid(absTolerance, maxEvaluations)

    @staticmethod
    def discreteSimpson(evaluation=1000):
        r"""discreteSimpson(Size evaluation=1000) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_discreteSimpson(evaluation)

    @staticmethod
    def discreteTrapezoid(evaluation=1000):
        r"""discreteTrapezoid(Size evaluation=1000) -> AnalyticHestonEngine_Integration"""
        return _QuantLib.AnalyticHestonEngine_Integration_discreteTrapezoid(evaluation)

    @staticmethod
    def andersenPiterbargIntegrationLimit(c_inf, epsilon, v0, t):
        r"""andersenPiterbargIntegrationLimit(Real c_inf, Real epsilon, Real v0, Real t) -> Real"""
        return _QuantLib.AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(c_inf, epsilon, v0, t)

    def calculate(self, *args):
        r"""calculate(AnalyticHestonEngine_Integration self, Real c_inf, ext::function< Real (Real) > const & f, doubleOrNull maxBound=Null< Real >()) -> Real"""
        return _QuantLib.AnalyticHestonEngine_Integration_calculate(self, *args)

    def numberOfEvaluations(self):
        r"""numberOfEvaluations(AnalyticHestonEngine_Integration self) -> Size"""
        return _QuantLib.AnalyticHestonEngine_Integration_numberOfEvaluations(self)

    def isAdaptiveIntegration(self):
        r"""isAdaptiveIntegration(AnalyticHestonEngine_Integration self) -> bool"""
        return _QuantLib.AnalyticHestonEngine_Integration_isAdaptiveIntegration(self)
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonEngine_Integration

# Register AnalyticHestonEngine_Integration in _QuantLib:
_QuantLib.AnalyticHestonEngine_Integration_swigregister(AnalyticHestonEngine_Integration)
class COSHestonEngine(PricingEngine):
    r"""Proxy of C++ COSHestonEngine class."""

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

    def __init__(self, model, L=16, N=200):
        r"""__init__(COSHestonEngine self, ext::shared_ptr< HestonModel > const & model, Real L=16, Size N=200) -> COSHestonEngine"""
        _QuantLib.COSHestonEngine_swiginit(self, _QuantLib.new_COSHestonEngine(model, L, N))
    __swig_destroy__ = _QuantLib.delete_COSHestonEngine

# Register COSHestonEngine in _QuantLib:
_QuantLib.COSHestonEngine_swigregister(COSHestonEngine)
class ExponentialFittingHestonEngine(PricingEngine):
    r"""Proxy of C++ ExponentialFittingHestonEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AndersenPiterbarg = _QuantLib.ExponentialFittingHestonEngine_AndersenPiterbarg
    
    AndersenPiterbargOptCV = _QuantLib.ExponentialFittingHestonEngine_AndersenPiterbargOptCV
    
    AsymptoticChF = _QuantLib.ExponentialFittingHestonEngine_AsymptoticChF
    
    OptimalCV = _QuantLib.ExponentialFittingHestonEngine_OptimalCV
    

    def __init__(self, *args):
        r"""__init__(ExponentialFittingHestonEngine self, ext::shared_ptr< HestonModel > const & model, ExponentialFittingHestonEngine::ControlVariate cv=AndersenPiterbargOptCV, doubleOrNull scaling=Null< Real >()) -> ExponentialFittingHestonEngine"""
        _QuantLib.ExponentialFittingHestonEngine_swiginit(self, _QuantLib.new_ExponentialFittingHestonEngine(*args))
    __swig_destroy__ = _QuantLib.delete_ExponentialFittingHestonEngine

# Register ExponentialFittingHestonEngine in _QuantLib:
_QuantLib.ExponentialFittingHestonEngine_swigregister(ExponentialFittingHestonEngine)
class AnalyticPTDHestonEngine(PricingEngine):
    r"""Proxy of C++ AnalyticPTDHestonEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Gatheral = _QuantLib.AnalyticPTDHestonEngine_Gatheral
    
    AndersenPiterbarg = _QuantLib.AnalyticPTDHestonEngine_AndersenPiterbarg
    

    def __init__(self, *args):
        r"""
        __init__(AnalyticPTDHestonEngine self, ext::shared_ptr< PiecewiseTimeDependentHestonModel > const & model, Real relTolerance, Size maxEvaluations) -> AnalyticPTDHestonEngine
        __init__(AnalyticPTDHestonEngine self, ext::shared_ptr< PiecewiseTimeDependentHestonModel > const & model, Size integrationOrder=144) -> AnalyticPTDHestonEngine
        __init__(AnalyticPTDHestonEngine self, ext::shared_ptr< PiecewiseTimeDependentHestonModel > const & model, AnalyticPTDHestonEngine::ComplexLogFormula cpxLog, AnalyticHestonEngine_Integration itg, Real andersenPiterbargEpsilon=1e-8) -> AnalyticPTDHestonEngine
        """
        _QuantLib.AnalyticPTDHestonEngine_swiginit(self, _QuantLib.new_AnalyticPTDHestonEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticPTDHestonEngine

# Register AnalyticPTDHestonEngine in _QuantLib:
_QuantLib.AnalyticPTDHestonEngine_swigregister(AnalyticPTDHestonEngine)
class BatesModel(HestonModel):
    r"""Proxy of C++ BatesModel class."""

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

    def __init__(self, process):
        r"""__init__(BatesModel self, ext::shared_ptr< BatesProcess > const & process) -> BatesModel"""
        _QuantLib.BatesModel_swiginit(self, _QuantLib.new_BatesModel(process))

    def nu(self):
        r"""nu(BatesModel self) -> Real"""
        return _QuantLib.BatesModel_nu(self)

    def delta(self):
        r"""delta(BatesModel self) -> Real"""
        return _QuantLib.BatesModel_delta(self)

    def lambda_parameter(self):
        r"""lambda_parameter(BatesModel self) -> Real"""
        return _QuantLib.BatesModel_lambda_parameter(self)
    __swig_destroy__ = _QuantLib.delete_BatesModel

# Register BatesModel in _QuantLib:
_QuantLib.BatesModel_swigregister(BatesModel)
class BatesEngine(PricingEngine):
    r"""Proxy of C++ BatesEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(BatesEngine self, ext::shared_ptr< BatesModel > const & model, Size integrationOrder=144) -> BatesEngine
        __init__(BatesEngine self, ext::shared_ptr< BatesModel > const & model, Real relTolerance, Size maxEvaluations) -> BatesEngine
        """
        _QuantLib.BatesEngine_swiginit(self, _QuantLib.new_BatesEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BatesEngine

# Register BatesEngine in _QuantLib:
_QuantLib.BatesEngine_swigregister(BatesEngine)
class IntegralEngine(PricingEngine):
    r"""Proxy of C++ IntegralEngine class."""

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

    def __init__(self, arg2):
        r"""__init__(IntegralEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2) -> IntegralEngine"""
        _QuantLib.IntegralEngine_swiginit(self, _QuantLib.new_IntegralEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_IntegralEngine

# Register IntegralEngine in _QuantLib:
_QuantLib.IntegralEngine_swigregister(IntegralEngine)
class BinomialCRRVanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< CoxRossRubinstein > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialCRRVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialCRRVanillaEngine"""
        _QuantLib.BinomialCRRVanillaEngine_swiginit(self, _QuantLib.new_BinomialCRRVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRVanillaEngine

# Register BinomialCRRVanillaEngine in _QuantLib:
_QuantLib.BinomialCRRVanillaEngine_swigregister(BinomialCRRVanillaEngine)
class BinomialJRVanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< JarrowRudd > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialJRVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialJRVanillaEngine"""
        _QuantLib.BinomialJRVanillaEngine_swiginit(self, _QuantLib.new_BinomialJRVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRVanillaEngine

# Register BinomialJRVanillaEngine in _QuantLib:
_QuantLib.BinomialJRVanillaEngine_swigregister(BinomialJRVanillaEngine)
class BinomialEQPVanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< AdditiveEQPBinomialTree > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialEQPVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialEQPVanillaEngine"""
        _QuantLib.BinomialEQPVanillaEngine_swiginit(self, _QuantLib.new_BinomialEQPVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPVanillaEngine

# Register BinomialEQPVanillaEngine in _QuantLib:
_QuantLib.BinomialEQPVanillaEngine_swigregister(BinomialEQPVanillaEngine)
class BinomialTrigeorgisVanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< Trigeorgis > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialTrigeorgisVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialTrigeorgisVanillaEngine"""
        _QuantLib.BinomialTrigeorgisVanillaEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisVanillaEngine

# Register BinomialTrigeorgisVanillaEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisVanillaEngine_swigregister(BinomialTrigeorgisVanillaEngine)
class BinomialTianVanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< Tian > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialTianVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialTianVanillaEngine"""
        _QuantLib.BinomialTianVanillaEngine_swiginit(self, _QuantLib.new_BinomialTianVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianVanillaEngine

# Register BinomialTianVanillaEngine in _QuantLib:
_QuantLib.BinomialTianVanillaEngine_swigregister(BinomialTianVanillaEngine)
class BinomialLRVanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< LeisenReimer > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialLRVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialLRVanillaEngine"""
        _QuantLib.BinomialLRVanillaEngine_swiginit(self, _QuantLib.new_BinomialLRVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRVanillaEngine

# Register BinomialLRVanillaEngine in _QuantLib:
_QuantLib.BinomialLRVanillaEngine_swigregister(BinomialLRVanillaEngine)
class BinomialJ4VanillaEngine(PricingEngine):
    r"""Proxy of C++ BinomialVanillaEngine< Joshi4 > class."""

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

    def __init__(self, arg2, steps):
        r"""__init__(BinomialJ4VanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialJ4VanillaEngine"""
        _QuantLib.BinomialJ4VanillaEngine_swiginit(self, _QuantLib.new_BinomialJ4VanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4VanillaEngine

# Register BinomialJ4VanillaEngine in _QuantLib:
_QuantLib.BinomialJ4VanillaEngine_swigregister(BinomialJ4VanillaEngine)

def BinomialVanillaEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRVanillaEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRVanillaEngine
    elif type == "eqp":
        cls = BinomialEQPVanillaEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisVanillaEngine
    elif type == "tian":
        cls = BinomialTianVanillaEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRVanillaEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4VanillaEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class LsmBasisSystem(object):
    r"""Proxy of C++ LsmBasisSystem class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Monomial = _QuantLib.LsmBasisSystem_Monomial
    
    Laguerre = _QuantLib.LsmBasisSystem_Laguerre
    
    Hermite = _QuantLib.LsmBasisSystem_Hermite
    
    Hyperbolic = _QuantLib.LsmBasisSystem_Hyperbolic
    
    Legendre = _QuantLib.LsmBasisSystem_Legendre
    
    Chebyshev = _QuantLib.LsmBasisSystem_Chebyshev
    
    Chebyshev2nd = _QuantLib.LsmBasisSystem_Chebyshev2nd
    

    def __init__(self):
        r"""__init__(LsmBasisSystem self) -> LsmBasisSystem"""
        _QuantLib.LsmBasisSystem_swiginit(self, _QuantLib.new_LsmBasisSystem())
    __swig_destroy__ = _QuantLib.delete_LsmBasisSystem

# Register LsmBasisSystem in _QuantLib:
_QuantLib.LsmBasisSystem_swigregister(LsmBasisSystem)
class MCPREuropeanEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPREuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanEngine"""
        _QuantLib.MCPREuropeanEngine_swiginit(self, _QuantLib.new_MCPREuropeanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanEngine

# Register MCPREuropeanEngine in _QuantLib:
_QuantLib.MCPREuropeanEngine_swigregister(MCPREuropeanEngine)
class MCLDEuropeanEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanEngine"""
        _QuantLib.MCLDEuropeanEngine_swiginit(self, _QuantLib.new_MCLDEuropeanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanEngine

# Register MCLDEuropeanEngine in _QuantLib:
_QuantLib.MCLDEuropeanEngine_swigregister(MCLDEuropeanEngine)

def MCEuropeanEngine(process,
                     traits,
                     timeSteps=None,
                     timeStepsPerYear=None,
                     brownianBridge=False,
                     antitheticVariate=False,
                     requiredSamples=None,
                     requiredTolerance=None,
                     maxSamples=None,
                     seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRAmericanEngine(PricingEngine):
    r"""Proxy of C++ MCAmericanEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRAmericanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull polynomOrder=2, LsmBasisSystem::PolynomType polynomType=Monomial, int nCalibrationSamples=2048, boost::optional< bool > antitheticVariateCalibration=boost::none, BigNatural seedCalibration=Null< Size >()) -> MCPRAmericanEngine"""
        _QuantLib.MCPRAmericanEngine_swiginit(self, _QuantLib.new_MCPRAmericanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRAmericanEngine

# Register MCPRAmericanEngine in _QuantLib:
_QuantLib.MCPRAmericanEngine_swigregister(MCPRAmericanEngine)
class MCLDAmericanEngine(PricingEngine):
    r"""Proxy of C++ MCAmericanEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDAmericanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull polynomOrder=2, LsmBasisSystem::PolynomType polynomType=Monomial, int nCalibrationSamples=2048, boost::optional< bool > antitheticVariateCalibration=boost::none, BigNatural seedCalibration=Null< Size >()) -> MCLDAmericanEngine"""
        _QuantLib.MCLDAmericanEngine_swiginit(self, _QuantLib.new_MCLDAmericanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDAmericanEngine

# Register MCLDAmericanEngine in _QuantLib:
_QuantLib.MCLDAmericanEngine_swigregister(MCLDAmericanEngine)

def MCAmericanEngine(process,
                     traits,
                     timeSteps=None,
                     timeStepsPerYear=None,
                     antitheticVariate=False,
                     controlVariate=False,
                     requiredSamples=None,
                     requiredTolerance=None,
                     maxSamples=None,
                     seed=0,
                     polynomOrder=2,
                     polynomType=LsmBasisSystem.Monomial,
                     nCalibrationSamples=2048,
                     antitheticVariateCalibration=None,
                     seedCalibration=None):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRAmericanEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDAmericanEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               controlVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               polynomOrder,
               polynomType,
               nCalibrationSamples,
               antitheticVariateCalibration,
               seedCalibration if seedCalibration is not None else nullInt())

class MCPREuropeanHestonEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanHestonEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPREuropeanHestonEngine self, ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanHestonEngine"""
        _QuantLib.MCPREuropeanHestonEngine_swiginit(self, _QuantLib.new_MCPREuropeanHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanHestonEngine

# Register MCPREuropeanHestonEngine in _QuantLib:
_QuantLib.MCPREuropeanHestonEngine_swigregister(MCPREuropeanHestonEngine)
class MCLDEuropeanHestonEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanHestonEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDEuropeanHestonEngine self, ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanHestonEngine"""
        _QuantLib.MCLDEuropeanHestonEngine_swiginit(self, _QuantLib.new_MCLDEuropeanHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanHestonEngine

# Register MCLDEuropeanHestonEngine in _QuantLib:
_QuantLib.MCLDEuropeanHestonEngine_swigregister(MCLDEuropeanHestonEngine)

def MCEuropeanHestonEngine(process,
                           traits,
                           timeSteps=None,
                           timeStepsPerYear=None,
                           antitheticVariate=False,
                           requiredSamples=None,
                           requiredTolerance=None,
                           maxSamples=None,
                           seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanHestonEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanHestonEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRDigitalEngine(PricingEngine):
    r"""Proxy of C++ MCDigitalEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRDigitalEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDigitalEngine"""
        _QuantLib.MCPRDigitalEngine_swiginit(self, _QuantLib.new_MCPRDigitalEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDigitalEngine

# Register MCPRDigitalEngine in _QuantLib:
_QuantLib.MCPRDigitalEngine_swigregister(MCPRDigitalEngine)
class MCLDDigitalEngine(PricingEngine):
    r"""Proxy of C++ MCDigitalEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDDigitalEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDigitalEngine"""
        _QuantLib.MCLDDigitalEngine_swiginit(self, _QuantLib.new_MCLDDigitalEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDigitalEngine

# Register MCLDDigitalEngine in _QuantLib:
_QuantLib.MCLDDigitalEngine_swigregister(MCLDDigitalEngine)

def MCDigitalEngine(process,
                    traits,
                    timeSteps=None,
                    timeStepsPerYear=None,
                    brownianBridge=False,
                    antitheticVariate=False,
                    requiredSamples=None,
                    requiredTolerance=None,
                    maxSamples=None,
                    seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDigitalEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDigitalEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class BaroneAdesiWhaleyApproximationEngine(PricingEngine):
    r"""Proxy of C++ BaroneAdesiWhaleyApproximationEngine class."""

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

    def __init__(self, process):
        r"""__init__(BaroneAdesiWhaleyApproximationEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> BaroneAdesiWhaleyApproximationEngine"""
        _QuantLib.BaroneAdesiWhaleyApproximationEngine_swiginit(self, _QuantLib.new_BaroneAdesiWhaleyApproximationEngine(process))
    __swig_destroy__ = _QuantLib.delete_BaroneAdesiWhaleyApproximationEngine

# Register BaroneAdesiWhaleyApproximationEngine in _QuantLib:
_QuantLib.BaroneAdesiWhaleyApproximationEngine_swigregister(BaroneAdesiWhaleyApproximationEngine)
class BjerksundStenslandApproximationEngine(PricingEngine):
    r"""Proxy of C++ BjerksundStenslandApproximationEngine class."""

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

    def __init__(self, process):
        r"""__init__(BjerksundStenslandApproximationEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> BjerksundStenslandApproximationEngine"""
        _QuantLib.BjerksundStenslandApproximationEngine_swiginit(self, _QuantLib.new_BjerksundStenslandApproximationEngine(process))
    __swig_destroy__ = _QuantLib.delete_BjerksundStenslandApproximationEngine

# Register BjerksundStenslandApproximationEngine in _QuantLib:
_QuantLib.BjerksundStenslandApproximationEngine_swigregister(BjerksundStenslandApproximationEngine)
class JuQuadraticApproximationEngine(PricingEngine):
    r"""Proxy of C++ JuQuadraticApproximationEngine class."""

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

    def __init__(self, process):
        r"""__init__(JuQuadraticApproximationEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> JuQuadraticApproximationEngine"""
        _QuantLib.JuQuadraticApproximationEngine_swiginit(self, _QuantLib.new_JuQuadraticApproximationEngine(process))
    __swig_destroy__ = _QuantLib.delete_JuQuadraticApproximationEngine

# Register JuQuadraticApproximationEngine in _QuantLib:
_QuantLib.JuQuadraticApproximationEngine_swigregister(JuQuadraticApproximationEngine)
class AnalyticDigitalAmericanEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDigitalAmericanEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticDigitalAmericanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDigitalAmericanEngine"""
        _QuantLib.AnalyticDigitalAmericanEngine_swiginit(self, _QuantLib.new_AnalyticDigitalAmericanEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanEngine

# Register AnalyticDigitalAmericanEngine in _QuantLib:
_QuantLib.AnalyticDigitalAmericanEngine_swigregister(AnalyticDigitalAmericanEngine)
class AnalyticDigitalAmericanKOEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDigitalAmericanKOEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticDigitalAmericanKOEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDigitalAmericanKOEngine"""
        _QuantLib.AnalyticDigitalAmericanKOEngine_swiginit(self, _QuantLib.new_AnalyticDigitalAmericanKOEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanKOEngine

# Register AnalyticDigitalAmericanKOEngine in _QuantLib:
_QuantLib.AnalyticDigitalAmericanKOEngine_swigregister(AnalyticDigitalAmericanKOEngine)
class DividendVanillaOption(OneAssetOption):
    r"""Proxy of C++ DividendVanillaOption class."""

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

    def __init__(self, payoff, exercise, dividendDates, dividends):
        r"""__init__(DividendVanillaOption self, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise, DateVector dividendDates, DoubleVector dividends) -> DividendVanillaOption"""
        _QuantLib.DividendVanillaOption_swiginit(self, _QuantLib.new_DividendVanillaOption(payoff, exercise, dividendDates, dividends))

    def impliedVolatility(self, targetValue, process, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-4, maxVol=4.0):
        r"""impliedVolatility(DividendVanillaOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility"""
        return _QuantLib.DividendVanillaOption_impliedVolatility(self, targetValue, process, accuracy, maxEvaluations, minVol, maxVol)
    __swig_destroy__ = _QuantLib.delete_DividendVanillaOption

# Register DividendVanillaOption in _QuantLib:
_QuantLib.DividendVanillaOption_swigregister(DividendVanillaOption)
class AnalyticDividendEuropeanEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDividendEuropeanEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticDividendEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDividendEuropeanEngine"""
        _QuantLib.AnalyticDividendEuropeanEngine_swiginit(self, _QuantLib.new_AnalyticDividendEuropeanEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDividendEuropeanEngine

# Register AnalyticDividendEuropeanEngine in _QuantLib:
_QuantLib.AnalyticDividendEuropeanEngine_swigregister(AnalyticDividendEuropeanEngine)
class QdPlusAmericanEngine(PricingEngine):
    r"""Proxy of C++ QdPlusAmericanEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Brent = _QuantLib.QdPlusAmericanEngine_Brent
    
    Newton = _QuantLib.QdPlusAmericanEngine_Newton
    
    Ridder = _QuantLib.QdPlusAmericanEngine_Ridder
    
    Halley = _QuantLib.QdPlusAmericanEngine_Halley
    
    SuperHalley = _QuantLib.QdPlusAmericanEngine_SuperHalley
    

    def __init__(self, *args, **kwargs):
        r"""__init__(QdPlusAmericanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > process, Size interpolationPoints=8, QdPlusAmericanEngine::SolverType solverType=Halley, Real eps=1e-6, Size maxIter=Null< Size >()) -> QdPlusAmericanEngine"""
        _QuantLib.QdPlusAmericanEngine_swiginit(self, _QuantLib.new_QdPlusAmericanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_QdPlusAmericanEngine

# Register QdPlusAmericanEngine in _QuantLib:
_QuantLib.QdPlusAmericanEngine_swigregister(QdPlusAmericanEngine)
class QdFpIterationScheme(object):
    r"""Proxy of C++ QdFpIterationScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register QdFpIterationScheme in _QuantLib:
_QuantLib.QdFpIterationScheme_swigregister(QdFpIterationScheme)
class QdFpLegendreScheme(QdFpIterationScheme):
    r"""Proxy of C++ QdFpLegendreScheme class."""

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

    def __init__(self, l, m, n, p):
        r"""__init__(QdFpLegendreScheme self, Size l, Size m, Size n, Size p) -> QdFpLegendreScheme"""
        _QuantLib.QdFpLegendreScheme_swiginit(self, _QuantLib.new_QdFpLegendreScheme(l, m, n, p))
    __swig_destroy__ = _QuantLib.delete_QdFpLegendreScheme

# Register QdFpLegendreScheme in _QuantLib:
_QuantLib.QdFpLegendreScheme_swigregister(QdFpLegendreScheme)
class QdFpLegendreTanhSinhScheme(QdFpLegendreScheme):
    r"""Proxy of C++ QdFpLegendreTanhSinhScheme class."""

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

    def __init__(self, l, m, n, eps):
        r"""__init__(QdFpLegendreTanhSinhScheme self, Size l, Size m, Size n, Real eps) -> QdFpLegendreTanhSinhScheme"""
        _QuantLib.QdFpLegendreTanhSinhScheme_swiginit(self, _QuantLib.new_QdFpLegendreTanhSinhScheme(l, m, n, eps))
    __swig_destroy__ = _QuantLib.delete_QdFpLegendreTanhSinhScheme

# Register QdFpLegendreTanhSinhScheme in _QuantLib:
_QuantLib.QdFpLegendreTanhSinhScheme_swigregister(QdFpLegendreTanhSinhScheme)
class QdFpTanhSinhIterationScheme(QdFpIterationScheme):
    r"""Proxy of C++ QdFpTanhSinhIterationScheme class."""

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

    def __init__(self, m, n, eps):
        r"""__init__(QdFpTanhSinhIterationScheme self, Size m, Size n, Real eps) -> QdFpTanhSinhIterationScheme"""
        _QuantLib.QdFpTanhSinhIterationScheme_swiginit(self, _QuantLib.new_QdFpTanhSinhIterationScheme(m, n, eps))
    __swig_destroy__ = _QuantLib.delete_QdFpTanhSinhIterationScheme

# Register QdFpTanhSinhIterationScheme in _QuantLib:
_QuantLib.QdFpTanhSinhIterationScheme_swigregister(QdFpTanhSinhIterationScheme)
class QdFpAmericanEngine(PricingEngine):
    r"""Proxy of C++ QdFpAmericanEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FP_A = _QuantLib.QdFpAmericanEngine_FP_A
    
    FP_B = _QuantLib.QdFpAmericanEngine_FP_B
    
    Auto = _QuantLib.QdFpAmericanEngine_Auto
    

    def __init__(self, *args):
        r"""__init__(QdFpAmericanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > bsProcess, ext::shared_ptr< QdFpIterationScheme > iterationScheme=accurateScheme(), QdFpAmericanEngine::FixedPointEquation fpEquation=Auto) -> QdFpAmericanEngine"""
        _QuantLib.QdFpAmericanEngine_swiginit(self, _QuantLib.new_QdFpAmericanEngine(*args))

    @staticmethod
    def fastScheme():
        r"""fastScheme() -> ext::shared_ptr< QdFpIterationScheme >"""
        return _QuantLib.QdFpAmericanEngine_fastScheme()

    @staticmethod
    def accurateScheme():
        r"""accurateScheme() -> ext::shared_ptr< QdFpIterationScheme >"""
        return _QuantLib.QdFpAmericanEngine_accurateScheme()

    @staticmethod
    def highPrecisionScheme():
        r"""highPrecisionScheme() -> ext::shared_ptr< QdFpIterationScheme >"""
        return _QuantLib.QdFpAmericanEngine_highPrecisionScheme()
    __swig_destroy__ = _QuantLib.delete_QdFpAmericanEngine

# Register QdFpAmericanEngine in _QuantLib:
_QuantLib.QdFpAmericanEngine_swigregister(QdFpAmericanEngine)
class FdmSchemeDesc(object):
    r"""Proxy of C++ FdmSchemeDesc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HundsdorferType = _QuantLib.FdmSchemeDesc_HundsdorferType
    
    DouglasType = _QuantLib.FdmSchemeDesc_DouglasType
    
    CraigSneydType = _QuantLib.FdmSchemeDesc_CraigSneydType
    
    ModifiedCraigSneydType = _QuantLib.FdmSchemeDesc_ModifiedCraigSneydType
    
    ImplicitEulerType = _QuantLib.FdmSchemeDesc_ImplicitEulerType
    
    ExplicitEulerType = _QuantLib.FdmSchemeDesc_ExplicitEulerType
    
    MethodOfLinesType = _QuantLib.FdmSchemeDesc_MethodOfLinesType
    
    TrBDF2Type = _QuantLib.FdmSchemeDesc_TrBDF2Type
    
    CrankNicolsonType = _QuantLib.FdmSchemeDesc_CrankNicolsonType
    

    def __init__(self, type, theta, mu):
        r"""__init__(FdmSchemeDesc self, FdmSchemeDesc::FdmSchemeType type, Real theta, Real mu) -> FdmSchemeDesc"""
        _QuantLib.FdmSchemeDesc_swiginit(self, _QuantLib.new_FdmSchemeDesc(type, theta, mu))
    type = property(_QuantLib.FdmSchemeDesc_type_get, doc=r"""type : q(const).FdmSchemeDesc::FdmSchemeType""")
    theta = property(_QuantLib.FdmSchemeDesc_theta_get, doc=r"""theta : q(const).Real""")
    mu = property(_QuantLib.FdmSchemeDesc_mu_get, doc=r"""mu : q(const).Real""")

    @staticmethod
    def Douglas():
        r"""Douglas() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_Douglas()

    @staticmethod
    def CrankNicolson():
        r"""CrankNicolson() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_CrankNicolson()

    @staticmethod
    def ImplicitEuler():
        r"""ImplicitEuler() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_ImplicitEuler()

    @staticmethod
    def ExplicitEuler():
        r"""ExplicitEuler() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_ExplicitEuler()

    @staticmethod
    def CraigSneyd():
        r"""CraigSneyd() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_CraigSneyd()

    @staticmethod
    def ModifiedCraigSneyd():
        r"""ModifiedCraigSneyd() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_ModifiedCraigSneyd()

    @staticmethod
    def Hundsdorfer():
        r"""Hundsdorfer() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_Hundsdorfer()

    @staticmethod
    def ModifiedHundsdorfer():
        r"""ModifiedHundsdorfer() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_ModifiedHundsdorfer()

    @staticmethod
    def MethodOfLines(eps=0.001, relInitStepSize=0.01):
        r"""MethodOfLines(Real eps=0.001, Real relInitStepSize=0.01) -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_MethodOfLines(eps, relInitStepSize)

    @staticmethod
    def TrBDF2():
        r"""TrBDF2() -> FdmSchemeDesc"""
        return _QuantLib.FdmSchemeDesc_TrBDF2()
    __swig_destroy__ = _QuantLib.delete_FdmSchemeDesc

# Register FdmSchemeDesc in _QuantLib:
_QuantLib.FdmSchemeDesc_swigregister(FdmSchemeDesc)
class FdmQuantoHelper(object):
    r"""Proxy of C++ FdmQuantoHelper class."""

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

    def __init__(self, rTS, fTS, fxVolTS, equityFxCorrelation, exchRateATMlevel):
        r"""__init__(FdmQuantoHelper self, ext::shared_ptr< YieldTermStructure > const & rTS, ext::shared_ptr< YieldTermStructure > const & fTS, ext::shared_ptr< BlackVolTermStructure > const & fxVolTS, Real equityFxCorrelation, Real exchRateATMlevel) -> FdmQuantoHelper"""
        _QuantLib.FdmQuantoHelper_swiginit(self, _QuantLib.new_FdmQuantoHelper(rTS, fTS, fxVolTS, equityFxCorrelation, exchRateATMlevel))
    __swig_destroy__ = _QuantLib.delete_FdmQuantoHelper

# Register FdmQuantoHelper in _QuantLib:
_QuantLib.FdmQuantoHelper_swigregister(FdmQuantoHelper)
class FdBlackScholesVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdBlackScholesVanillaEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Spot = _QuantLib.FdBlackScholesVanillaEngine_Spot
    
    Escrowed = _QuantLib.FdBlackScholesVanillaEngine_Escrowed
    

    def __init__(self, *args):
        r"""
        __init__(FdBlackScholesVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot) -> FdBlackScholesVanillaEngine
        __init__(FdBlackScholesVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot) -> FdBlackScholesVanillaEngine
        """
        _QuantLib.FdBlackScholesVanillaEngine_swiginit(self, _QuantLib.new_FdBlackScholesVanillaEngine(*args))

    @staticmethod
    def make(*args, **kwargs):
        r"""make(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >(), Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot) -> ext::shared_ptr< FdBlackScholesVanillaEngine >"""
        return _QuantLib.FdBlackScholesVanillaEngine_make(*args, **kwargs)
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesVanillaEngine

# Register FdBlackScholesVanillaEngine in _QuantLib:
_QuantLib.FdBlackScholesVanillaEngine_swigregister(FdBlackScholesVanillaEngine)
class FdBlackScholesShoutEngine(PricingEngine):
    r"""Proxy of C++ FdBlackScholesShoutEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdBlackScholesShoutEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas()) -> FdBlackScholesShoutEngine"""
        _QuantLib.FdBlackScholesShoutEngine_swiginit(self, _QuantLib.new_FdBlackScholesShoutEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesShoutEngine

# Register FdBlackScholesShoutEngine in _QuantLib:
_QuantLib.FdBlackScholesShoutEngine_swigregister(FdBlackScholesShoutEngine)
class FdOrnsteinUhlenbeckVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdOrnsteinUhlenbeckVanillaEngine class."""

    thisown = 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):
        r"""__init__(FdOrnsteinUhlenbeckVanillaEngine self, ext::shared_ptr< OrnsteinUhlenbeckProcess > const & arg2, ext::shared_ptr< YieldTermStructure > const & rTS, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, Real epsilon=0.0001, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas()) -> FdOrnsteinUhlenbeckVanillaEngine"""
        _QuantLib.FdOrnsteinUhlenbeckVanillaEngine_swiginit(self, _QuantLib.new_FdOrnsteinUhlenbeckVanillaEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_FdOrnsteinUhlenbeckVanillaEngine

# Register FdOrnsteinUhlenbeckVanillaEngine in _QuantLib:
_QuantLib.FdOrnsteinUhlenbeckVanillaEngine_swigregister(FdOrnsteinUhlenbeckVanillaEngine)
class FdBatesVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdBatesVanillaEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdBatesVanillaEngine self, ext::shared_ptr< BatesModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdBatesVanillaEngine"""
        _QuantLib.FdBatesVanillaEngine_swiginit(self, _QuantLib.new_FdBatesVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBatesVanillaEngine

# Register FdBatesVanillaEngine in _QuantLib:
_QuantLib.FdBatesVanillaEngine_swigregister(FdBatesVanillaEngine)
class FdHestonVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdHestonVanillaEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(FdHestonVanillaEngine self, ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0) -> FdHestonVanillaEngine
        __init__(FdHestonVanillaEngine self, ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0) -> FdHestonVanillaEngine
        """
        _QuantLib.FdHestonVanillaEngine_swiginit(self, _QuantLib.new_FdHestonVanillaEngine(*args))

    @staticmethod
    def make(*args, **kwargs):
        r"""make(ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >(), Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0) -> ext::shared_ptr< FdHestonVanillaEngine >"""
        return _QuantLib.FdHestonVanillaEngine_make(*args, **kwargs)
    __swig_destroy__ = _QuantLib.delete_FdHestonVanillaEngine

# Register FdHestonVanillaEngine in _QuantLib:
_QuantLib.FdHestonVanillaEngine_swigregister(FdHestonVanillaEngine)
class AnalyticCEVEngine(PricingEngine):
    r"""Proxy of C++ AnalyticCEVEngine class."""

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

    def __init__(self, f0, alpha, beta, rTS):
        r"""__init__(AnalyticCEVEngine self, Real f0, Real alpha, Real beta, YieldTermStructureHandle rTS) -> AnalyticCEVEngine"""
        _QuantLib.AnalyticCEVEngine_swiginit(self, _QuantLib.new_AnalyticCEVEngine(f0, alpha, beta, rTS))
    __swig_destroy__ = _QuantLib.delete_AnalyticCEVEngine

# Register AnalyticCEVEngine in _QuantLib:
_QuantLib.AnalyticCEVEngine_swigregister(AnalyticCEVEngine)
class FdCEVVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdCEVVanillaEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdCEVVanillaEngine self, Real f0, Real alpha, Real beta, YieldTermStructureHandle rTS, Size tGrid=50, Size xGrid=400, Size dampingSteps=0, Real scalingFactor=1.0, Real eps=1e-4, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas()) -> FdCEVVanillaEngine"""
        _QuantLib.FdCEVVanillaEngine_swiginit(self, _QuantLib.new_FdCEVVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdCEVVanillaEngine

# Register FdCEVVanillaEngine in _QuantLib:
_QuantLib.FdCEVVanillaEngine_swigregister(FdCEVVanillaEngine)
class FdSabrVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdSabrVanillaEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdSabrVanillaEngine self, Real f0, Real alpha, Real beta, Real nu, Real rho, YieldTermStructureHandle rTS, Size tGrid=50, Size fGrid=400, Size xGrid=50, Size dampingSteps=0, Real scalingFactor=1.0, Real eps=1e-4, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdSabrVanillaEngine"""
        _QuantLib.FdSabrVanillaEngine_swiginit(self, _QuantLib.new_FdSabrVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdSabrVanillaEngine

# Register FdSabrVanillaEngine in _QuantLib:
_QuantLib.FdSabrVanillaEngine_swigregister(FdSabrVanillaEngine)
class FdHestonHullWhiteVanillaEngine(PricingEngine):
    r"""Proxy of C++ FdHestonHullWhiteVanillaEngine class."""

    thisown = 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):
        r"""__init__(FdHestonHullWhiteVanillaEngine self, ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhiteProcess > hwProcess, Real corrEquityShortRate, Size tGrid=50, Size xGrid=100, Size vGrid=40, Size rGrid=20, Size dampingSteps=0, bool controlVariate=True, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdHestonHullWhiteVanillaEngine"""
        _QuantLib.FdHestonHullWhiteVanillaEngine_swiginit(self, _QuantLib.new_FdHestonHullWhiteVanillaEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_FdHestonHullWhiteVanillaEngine

# Register FdHestonHullWhiteVanillaEngine in _QuantLib:
_QuantLib.FdHestonHullWhiteVanillaEngine_swigregister(FdHestonHullWhiteVanillaEngine)
class AnalyticHestonHullWhiteEngine(PricingEngine):
    r"""Proxy of C++ AnalyticHestonHullWhiteEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(AnalyticHestonHullWhiteEngine self, ext::shared_ptr< HestonModel > const & hestonModel, ext::shared_ptr< HullWhite > hullWhiteModel, Size integrationOrder=144) -> AnalyticHestonHullWhiteEngine
        __init__(AnalyticHestonHullWhiteEngine self, ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhite > hullWhiteModel, Real relTolerance, Size maxEvaluations) -> AnalyticHestonHullWhiteEngine
        """
        _QuantLib.AnalyticHestonHullWhiteEngine_swiginit(self, _QuantLib.new_AnalyticHestonHullWhiteEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonHullWhiteEngine

# Register AnalyticHestonHullWhiteEngine in _QuantLib:
_QuantLib.AnalyticHestonHullWhiteEngine_swigregister(AnalyticHestonHullWhiteEngine)
class AnalyticH1HWEngine(PricingEngine):
    r"""Proxy of C++ AnalyticH1HWEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(AnalyticH1HWEngine self, ext::shared_ptr< HestonModel > const & hestonModel, ext::shared_ptr< HullWhite > const & hullWhiteModel, Real rhoSr, Size integrationOrder=144) -> AnalyticH1HWEngine
        __init__(AnalyticH1HWEngine self, ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhite > const & hullWhiteModel, Real rhoSr, Real relTolerance, Size maxEvaluations) -> AnalyticH1HWEngine
        """
        _QuantLib.AnalyticH1HWEngine_swiginit(self, _QuantLib.new_AnalyticH1HWEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticH1HWEngine

# Register AnalyticH1HWEngine in _QuantLib:
_QuantLib.AnalyticH1HWEngine_swigregister(AnalyticH1HWEngine)
class ForwardEuropeanEngine(PricingEngine):
    r"""Proxy of C++ ForwardEuropeanEngine class."""

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

    def __init__(self, arg2):
        r"""__init__(ForwardEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2) -> ForwardEuropeanEngine"""
        _QuantLib.ForwardEuropeanEngine_swiginit(self, _QuantLib.new_ForwardEuropeanEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_ForwardEuropeanEngine

# Register ForwardEuropeanEngine in _QuantLib:
_QuantLib.ForwardEuropeanEngine_swigregister(ForwardEuropeanEngine)
class QuantoEuropeanEngine(PricingEngine):
    r"""Proxy of C++ QuantoEuropeanEngine class."""

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

    def __init__(self, process, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        r"""__init__(QuantoEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, YieldTermStructureHandle foreignRiskFreeRate, BlackVolTermStructureHandle exchangeRateVolatility, QuoteHandle correlation) -> QuantoEuropeanEngine"""
        _QuantLib.QuantoEuropeanEngine_swiginit(self, _QuantLib.new_QuantoEuropeanEngine(process, foreignRiskFreeRate, exchangeRateVolatility, correlation))
    __swig_destroy__ = _QuantLib.delete_QuantoEuropeanEngine

# Register QuantoEuropeanEngine in _QuantLib:
_QuantLib.QuantoEuropeanEngine_swigregister(QuantoEuropeanEngine)
class QuantoForwardEuropeanEngine(PricingEngine):
    r"""Proxy of C++ QuantoForwardEuropeanEngine class."""

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

    def __init__(self, process, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        r"""__init__(QuantoForwardEuropeanEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, YieldTermStructureHandle foreignRiskFreeRate, BlackVolTermStructureHandle exchangeRateVolatility, QuoteHandle correlation) -> QuantoForwardEuropeanEngine"""
        _QuantLib.QuantoForwardEuropeanEngine_swiginit(self, _QuantLib.new_QuantoForwardEuropeanEngine(process, foreignRiskFreeRate, exchangeRateVolatility, correlation))
    __swig_destroy__ = _QuantLib.delete_QuantoForwardEuropeanEngine

# Register QuantoForwardEuropeanEngine in _QuantLib:
_QuantLib.QuantoForwardEuropeanEngine_swigregister(QuantoForwardEuropeanEngine)
class AnalyticHestonForwardEuropeanEngine(PricingEngine):
    r"""Proxy of C++ AnalyticHestonForwardEuropeanEngine class."""

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

    def __init__(self, process, integrationOrder=144):
        r"""__init__(AnalyticHestonForwardEuropeanEngine self, ext::shared_ptr< HestonProcess > const & process, Size integrationOrder=144) -> AnalyticHestonForwardEuropeanEngine"""
        _QuantLib.AnalyticHestonForwardEuropeanEngine_swiginit(self, _QuantLib.new_AnalyticHestonForwardEuropeanEngine(process, integrationOrder))
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonForwardEuropeanEngine

# Register AnalyticHestonForwardEuropeanEngine in _QuantLib:
_QuantLib.AnalyticHestonForwardEuropeanEngine_swigregister(AnalyticHestonForwardEuropeanEngine)
class MCPRForwardEuropeanBSEngine(PricingEngine):
    r"""Proxy of C++ MCForwardEuropeanBSEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRForwardEuropeanBSEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRForwardEuropeanBSEngine"""
        _QuantLib.MCPRForwardEuropeanBSEngine_swiginit(self, _QuantLib.new_MCPRForwardEuropeanBSEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRForwardEuropeanBSEngine

# Register MCPRForwardEuropeanBSEngine in _QuantLib:
_QuantLib.MCPRForwardEuropeanBSEngine_swigregister(MCPRForwardEuropeanBSEngine)
class MCLDForwardEuropeanBSEngine(PricingEngine):
    r"""Proxy of C++ MCForwardEuropeanBSEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDForwardEuropeanBSEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDForwardEuropeanBSEngine"""
        _QuantLib.MCLDForwardEuropeanBSEngine_swiginit(self, _QuantLib.new_MCLDForwardEuropeanBSEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDForwardEuropeanBSEngine

# Register MCLDForwardEuropeanBSEngine in _QuantLib:
_QuantLib.MCLDForwardEuropeanBSEngine_swigregister(MCLDForwardEuropeanBSEngine)

def MCForwardEuropeanBSEngine(process,
                              traits,
                              timeSteps=None,
                              timeStepsPerYear=None,
                              brownianBridge=False,
                              antitheticVariate=False,
                              requiredSamples=None,
                              requiredTolerance=None,
                              maxSamples=None,
                              seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRForwardEuropeanBSEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDForwardEuropeanBSEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRForwardEuropeanHestonEngine(PricingEngine):
    r"""Proxy of C++ MCForwardEuropeanHestonEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRForwardEuropeanHestonEngine self, ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, bool controlVariate=False) -> MCPRForwardEuropeanHestonEngine"""
        _QuantLib.MCPRForwardEuropeanHestonEngine_swiginit(self, _QuantLib.new_MCPRForwardEuropeanHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRForwardEuropeanHestonEngine

# Register MCPRForwardEuropeanHestonEngine in _QuantLib:
_QuantLib.MCPRForwardEuropeanHestonEngine_swigregister(MCPRForwardEuropeanHestonEngine)
class MCLDForwardEuropeanHestonEngine(PricingEngine):
    r"""Proxy of C++ MCForwardEuropeanHestonEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDForwardEuropeanHestonEngine self, ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, bool controlVariate=False) -> MCLDForwardEuropeanHestonEngine"""
        _QuantLib.MCLDForwardEuropeanHestonEngine_swiginit(self, _QuantLib.new_MCLDForwardEuropeanHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDForwardEuropeanHestonEngine

# Register MCLDForwardEuropeanHestonEngine in _QuantLib:
_QuantLib.MCLDForwardEuropeanHestonEngine_swigregister(MCLDForwardEuropeanHestonEngine)

def MCForwardEuropeanHestonEngine(process,
                                  traits,
                                  timeSteps=None,
                                  timeStepsPerYear=None,
                                  antitheticVariate=False,
                                  requiredSamples=None,
                                  requiredTolerance=None,
                                  maxSamples=None,
                                  seed=0,
                                  controlVariate=False):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRForwardEuropeanHestonEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDForwardEuropeanHestonEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               controlVariate)

class BlackCalculator(object):
    r"""Proxy of C++ BlackCalculator class."""

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

    def __init__(self, payoff, forward, stdDev, discount=1.0):
        r"""__init__(BlackCalculator self, ext::shared_ptr< StrikedTypePayoff > const & payoff, Real forward, Real stdDev, Real discount=1.0) -> BlackCalculator"""
        _QuantLib.BlackCalculator_swiginit(self, _QuantLib.new_BlackCalculator(payoff, forward, stdDev, discount))

    def value(self):
        r"""value(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_value(self)

    def deltaForward(self):
        r"""deltaForward(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_deltaForward(self)

    def delta(self, spot):
        r"""delta(BlackCalculator self, Real spot) -> Real"""
        return _QuantLib.BlackCalculator_delta(self, spot)

    def elasticityForward(self):
        r"""elasticityForward(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_elasticityForward(self)

    def elasticity(self, spot):
        r"""elasticity(BlackCalculator self, Real spot) -> Real"""
        return _QuantLib.BlackCalculator_elasticity(self, spot)

    def gammaForward(self):
        r"""gammaForward(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_gammaForward(self)

    def gamma(self, spot):
        r"""gamma(BlackCalculator self, Real spot) -> Real"""
        return _QuantLib.BlackCalculator_gamma(self, spot)

    def theta(self, spot, maturity):
        r"""theta(BlackCalculator self, Real spot, Time maturity) -> Real"""
        return _QuantLib.BlackCalculator_theta(self, spot, maturity)

    def thetaPerDay(self, spot, maturity):
        r"""thetaPerDay(BlackCalculator self, Real spot, Time maturity) -> Real"""
        return _QuantLib.BlackCalculator_thetaPerDay(self, spot, maturity)

    def vega(self, maturity):
        r"""vega(BlackCalculator self, Time maturity) -> Real"""
        return _QuantLib.BlackCalculator_vega(self, maturity)

    def rho(self, maturity):
        r"""rho(BlackCalculator self, Time maturity) -> Real"""
        return _QuantLib.BlackCalculator_rho(self, maturity)

    def dividendRho(self, maturity):
        r"""dividendRho(BlackCalculator self, Time maturity) -> Real"""
        return _QuantLib.BlackCalculator_dividendRho(self, maturity)

    def itmCashProbability(self):
        r"""itmCashProbability(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_itmCashProbability(self)

    def itmAssetProbability(self):
        r"""itmAssetProbability(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_itmAssetProbability(self)

    def strikeSensitivity(self):
        r"""strikeSensitivity(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_strikeSensitivity(self)

    def alpha(self):
        r"""alpha(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_alpha(self)

    def beta(self):
        r"""beta(BlackCalculator self) -> Real"""
        return _QuantLib.BlackCalculator_beta(self)
    __swig_destroy__ = _QuantLib.delete_BlackCalculator

# Register BlackCalculator in _QuantLib:
_QuantLib.BlackCalculator_swigregister(BlackCalculator)
class VarianceGammaEngine(PricingEngine):
    r"""Proxy of C++ VarianceGammaEngine class."""

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

    def __init__(self, process):
        r"""__init__(VarianceGammaEngine self, ext::shared_ptr< VarianceGammaProcess > const & process) -> VarianceGammaEngine"""
        _QuantLib.VarianceGammaEngine_swiginit(self, _QuantLib.new_VarianceGammaEngine(process))
    __swig_destroy__ = _QuantLib.delete_VarianceGammaEngine

# Register VarianceGammaEngine in _QuantLib:
_QuantLib.VarianceGammaEngine_swigregister(VarianceGammaEngine)
class FFTVarianceGammaEngine(PricingEngine):
    r"""Proxy of C++ FFTVarianceGammaEngine class."""

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

    def __init__(self, process, logStrikeSpacing=0.001):
        r"""__init__(FFTVarianceGammaEngine self, ext::shared_ptr< VarianceGammaProcess > const & process, Real logStrikeSpacing=0.001) -> FFTVarianceGammaEngine"""
        _QuantLib.FFTVarianceGammaEngine_swiginit(self, _QuantLib.new_FFTVarianceGammaEngine(process, logStrikeSpacing))

    def precalculate(self, optionList):
        r"""precalculate(FFTVarianceGammaEngine self, InstrumentVector optionList)"""
        return _QuantLib.FFTVarianceGammaEngine_precalculate(self, optionList)
    __swig_destroy__ = _QuantLib.delete_FFTVarianceGammaEngine

# Register FFTVarianceGammaEngine in _QuantLib:
_QuantLib.FFTVarianceGammaEngine_swigregister(FFTVarianceGammaEngine)
class GJRGARCHModel(CalibratedModel):
    r"""Proxy of C++ GJRGARCHModel class."""

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

    def __init__(self, process):
        r"""__init__(GJRGARCHModel self, ext::shared_ptr< GJRGARCHProcess > const & process) -> GJRGARCHModel"""
        _QuantLib.GJRGARCHModel_swiginit(self, _QuantLib.new_GJRGARCHModel(process))

    def omega(self):
        r"""omega(GJRGARCHModel self) -> Real"""
        return _QuantLib.GJRGARCHModel_omega(self)

    def alpha(self):
        r"""alpha(GJRGARCHModel self) -> Real"""
        return _QuantLib.GJRGARCHModel_alpha(self)

    def beta(self):
        r"""beta(GJRGARCHModel self) -> Real"""
        return _QuantLib.GJRGARCHModel_beta(self)

    def gamma(self):
        r"""gamma(GJRGARCHModel self) -> Real"""
        return _QuantLib.GJRGARCHModel_gamma(self)

    def lambda_parameter(self):
        r"""lambda_parameter(GJRGARCHModel self) -> Real"""
        return _QuantLib.GJRGARCHModel_lambda_parameter(self)

    def v0(self):
        r"""v0(GJRGARCHModel self) -> Real"""
        return _QuantLib.GJRGARCHModel_v0(self)
    __swig_destroy__ = _QuantLib.delete_GJRGARCHModel

# Register GJRGARCHModel in _QuantLib:
_QuantLib.GJRGARCHModel_swigregister(GJRGARCHModel)
class AnalyticGJRGARCHEngine(PricingEngine):
    r"""Proxy of C++ AnalyticGJRGARCHEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticGJRGARCHEngine self, ext::shared_ptr< GJRGARCHModel > const & process) -> AnalyticGJRGARCHEngine"""
        _QuantLib.AnalyticGJRGARCHEngine_swiginit(self, _QuantLib.new_AnalyticGJRGARCHEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticGJRGARCHEngine

# Register AnalyticGJRGARCHEngine in _QuantLib:
_QuantLib.AnalyticGJRGARCHEngine_swigregister(AnalyticGJRGARCHEngine)
class MCPREuropeanGJRGARCHEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanGJRGARCHEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPREuropeanGJRGARCHEngine self, ext::shared_ptr< GJRGARCHProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanGJRGARCHEngine"""
        _QuantLib.MCPREuropeanGJRGARCHEngine_swiginit(self, _QuantLib.new_MCPREuropeanGJRGARCHEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanGJRGARCHEngine

# Register MCPREuropeanGJRGARCHEngine in _QuantLib:
_QuantLib.MCPREuropeanGJRGARCHEngine_swigregister(MCPREuropeanGJRGARCHEngine)
class MCLDEuropeanGJRGARCHEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanGJRGARCHEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDEuropeanGJRGARCHEngine self, ext::shared_ptr< GJRGARCHProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanGJRGARCHEngine"""
        _QuantLib.MCLDEuropeanGJRGARCHEngine_swiginit(self, _QuantLib.new_MCLDEuropeanGJRGARCHEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanGJRGARCHEngine

# Register MCLDEuropeanGJRGARCHEngine in _QuantLib:
_QuantLib.MCLDEuropeanGJRGARCHEngine_swigregister(MCLDEuropeanGJRGARCHEngine)

def MCEuropeanGJRGARCHEngine(process,
                             traits,
                             timeSteps=None,
                             timeStepsPerYear=None,
                             antitheticVariate=False,
                             requiredSamples=None,
                             requiredTolerance=None,
                             maxSamples=None,
                             seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanGJRGARCHEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanGJRGARCHEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class Average(object):
    r"""Proxy of C++ Average class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Arithmetic = _QuantLib.Average_Arithmetic
    
    Geometric = _QuantLib.Average_Geometric
    

    def __init__(self):
        r"""__init__(Average self) -> Average"""
        _QuantLib.Average_swiginit(self, _QuantLib.new_Average())
    __swig_destroy__ = _QuantLib.delete_Average

# Register Average in _QuantLib:
_QuantLib.Average_swigregister(Average)
class ContinuousAveragingAsianOption(OneAssetOption):
    r"""Proxy of C++ ContinuousAveragingAsianOption class."""

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

    def __init__(self, averageType, payoff, exercise):
        r"""__init__(ContinuousAveragingAsianOption self, Average::Type averageType, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousAveragingAsianOption"""
        _QuantLib.ContinuousAveragingAsianOption_swiginit(self, _QuantLib.new_ContinuousAveragingAsianOption(averageType, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ContinuousAveragingAsianOption

# Register ContinuousAveragingAsianOption in _QuantLib:
_QuantLib.ContinuousAveragingAsianOption_swigregister(ContinuousAveragingAsianOption)
class DiscreteAveragingAsianOption(OneAssetOption):
    r"""Proxy of C++ DiscreteAveragingAsianOption class."""

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

    def __init__(self, *args):
        r"""
        __init__(DiscreteAveragingAsianOption self, Average::Type averageType, Real runningAccumulator, Size pastFixings, DateVector fixingDates, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> DiscreteAveragingAsianOption
        __init__(DiscreteAveragingAsianOption self, Average::Type averageType, DateVector fixingDates, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise, DoubleVector allPastFixings=std::vector< Real >()) -> DiscreteAveragingAsianOption
        """
        _QuantLib.DiscreteAveragingAsianOption_swiginit(self, _QuantLib.new_DiscreteAveragingAsianOption(*args))

    def timeGrid(self):
        r"""timeGrid(DiscreteAveragingAsianOption self) -> TimeGrid"""
        return _QuantLib.DiscreteAveragingAsianOption_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_DiscreteAveragingAsianOption

# Register DiscreteAveragingAsianOption in _QuantLib:
_QuantLib.DiscreteAveragingAsianOption_swigregister(DiscreteAveragingAsianOption)
class AnalyticContinuousGeometricAveragePriceAsianEngine(PricingEngine):
    r"""Proxy of C++ AnalyticContinuousGeometricAveragePriceAsianEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticContinuousGeometricAveragePriceAsianEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousGeometricAveragePriceAsianEngine"""
        _QuantLib.AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit(self, _QuantLib.new_AnalyticContinuousGeometricAveragePriceAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousGeometricAveragePriceAsianEngine

# Register AnalyticContinuousGeometricAveragePriceAsianEngine in _QuantLib:
_QuantLib.AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister(AnalyticContinuousGeometricAveragePriceAsianEngine)
class AnalyticContinuousGeometricAveragePriceAsianHestonEngine(PricingEngine):
    r"""Proxy of C++ AnalyticContinuousGeometricAveragePriceAsianHestonEngine class."""

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

    def __init__(self, process, summationCutoff=50, xiRightLimit=100.0):
        r"""__init__(AnalyticContinuousGeometricAveragePriceAsianHestonEngine self, ext::shared_ptr< HestonProcess > const & process, Size summationCutoff=50, Real xiRightLimit=100.0) -> AnalyticContinuousGeometricAveragePriceAsianHestonEngine"""
        _QuantLib.AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swiginit(self, _QuantLib.new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine(process, summationCutoff, xiRightLimit))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine

# Register AnalyticContinuousGeometricAveragePriceAsianHestonEngine in _QuantLib:
_QuantLib.AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swigregister(AnalyticContinuousGeometricAveragePriceAsianHestonEngine)
class AnalyticDiscreteGeometricAveragePriceAsianEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDiscreteGeometricAveragePriceAsianEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticDiscreteGeometricAveragePriceAsianEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDiscreteGeometricAveragePriceAsianEngine"""
        _QuantLib.AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit(self, _QuantLib.new_AnalyticDiscreteGeometricAveragePriceAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAveragePriceAsianEngine

# Register AnalyticDiscreteGeometricAveragePriceAsianEngine in _QuantLib:
_QuantLib.AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister(AnalyticDiscreteGeometricAveragePriceAsianEngine)
class AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDiscreteGeometricAveragePriceAsianHestonEngine class."""

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

    def __init__(self, process, xiRightLimit=100.0):
        r"""__init__(AnalyticDiscreteGeometricAveragePriceAsianHestonEngine self, ext::shared_ptr< HestonProcess > const & process, Real xiRightLimit=100.0) -> AnalyticDiscreteGeometricAveragePriceAsianHestonEngine"""
        _QuantLib.AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swiginit(self, _QuantLib.new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(process, xiRightLimit))
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine

# Register AnalyticDiscreteGeometricAveragePriceAsianHestonEngine in _QuantLib:
_QuantLib.AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swigregister(AnalyticDiscreteGeometricAveragePriceAsianHestonEngine)
class AnalyticDiscreteGeometricAverageStrikeAsianEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDiscreteGeometricAverageStrikeAsianEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticDiscreteGeometricAverageStrikeAsianEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDiscreteGeometricAverageStrikeAsianEngine"""
        _QuantLib.AnalyticDiscreteGeometricAverageStrikeAsianEngine_swiginit(self, _QuantLib.new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine

# Register AnalyticDiscreteGeometricAverageStrikeAsianEngine in _QuantLib:
_QuantLib.AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister(AnalyticDiscreteGeometricAverageStrikeAsianEngine)
class MCPRDiscreteArithmeticAPEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteArithmeticAPEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRDiscreteArithmeticAPEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDiscreteArithmeticAPEngine"""
        _QuantLib.MCPRDiscreteArithmeticAPEngine_swiginit(self, _QuantLib.new_MCPRDiscreteArithmeticAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteArithmeticAPEngine

# Register MCPRDiscreteArithmeticAPEngine in _QuantLib:
_QuantLib.MCPRDiscreteArithmeticAPEngine_swigregister(MCPRDiscreteArithmeticAPEngine)
class MCLDDiscreteArithmeticAPEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteArithmeticAPEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDDiscreteArithmeticAPEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDiscreteArithmeticAPEngine"""
        _QuantLib.MCLDDiscreteArithmeticAPEngine_swiginit(self, _QuantLib.new_MCLDDiscreteArithmeticAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteArithmeticAPEngine

# Register MCLDDiscreteArithmeticAPEngine in _QuantLib:
_QuantLib.MCLDDiscreteArithmeticAPEngine_swigregister(MCLDDiscreteArithmeticAPEngine)

def MCDiscreteArithmeticAPEngine(process,
                                 traits,
                                 brownianBridge=False,
                                 antitheticVariate=False,
                                 controlVariate=False,
                                 requiredSamples=None,
                                 requiredTolerance=None,
                                 maxSamples=None,
                                 seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteArithmeticAPEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteArithmeticAPEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               controlVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRDiscreteArithmeticAPHestonEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteArithmeticAPHestonEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRDiscreteArithmeticAPHestonEngine self, ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool controlVariate=False) -> MCPRDiscreteArithmeticAPHestonEngine"""
        _QuantLib.MCPRDiscreteArithmeticAPHestonEngine_swiginit(self, _QuantLib.new_MCPRDiscreteArithmeticAPHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteArithmeticAPHestonEngine

# Register MCPRDiscreteArithmeticAPHestonEngine in _QuantLib:
_QuantLib.MCPRDiscreteArithmeticAPHestonEngine_swigregister(MCPRDiscreteArithmeticAPHestonEngine)
class MCLDDiscreteArithmeticAPHestonEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDDiscreteArithmeticAPHestonEngine self, ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool controlVariate=False) -> MCLDDiscreteArithmeticAPHestonEngine"""
        _QuantLib.MCLDDiscreteArithmeticAPHestonEngine_swiginit(self, _QuantLib.new_MCLDDiscreteArithmeticAPHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteArithmeticAPHestonEngine

# Register MCLDDiscreteArithmeticAPHestonEngine in _QuantLib:
_QuantLib.MCLDDiscreteArithmeticAPHestonEngine_swigregister(MCLDDiscreteArithmeticAPHestonEngine)

def MCDiscreteArithmeticAPHestonEngine(process,
                                       traits,
                                       antitheticVariate=False,
                                       requiredSamples=None,
                                       requiredTolerance=None,
                                       maxSamples=None,
                                       seed=0,
                                       timeSteps=None,
                                       timeStepsPerYear=None,
                                       controlVariate=False):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteArithmeticAPHestonEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteArithmeticAPHestonEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               timeSteps,
               timeStepsPerYear,
               controlVariate)

class MCPRDiscreteArithmeticASEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteArithmeticASEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRDiscreteArithmeticASEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDiscreteArithmeticASEngine"""
        _QuantLib.MCPRDiscreteArithmeticASEngine_swiginit(self, _QuantLib.new_MCPRDiscreteArithmeticASEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteArithmeticASEngine

# Register MCPRDiscreteArithmeticASEngine in _QuantLib:
_QuantLib.MCPRDiscreteArithmeticASEngine_swigregister(MCPRDiscreteArithmeticASEngine)
class MCLDDiscreteArithmeticASEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteArithmeticASEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDDiscreteArithmeticASEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDiscreteArithmeticASEngine"""
        _QuantLib.MCLDDiscreteArithmeticASEngine_swiginit(self, _QuantLib.new_MCLDDiscreteArithmeticASEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteArithmeticASEngine

# Register MCLDDiscreteArithmeticASEngine in _QuantLib:
_QuantLib.MCLDDiscreteArithmeticASEngine_swigregister(MCLDDiscreteArithmeticASEngine)

def MCDiscreteArithmeticASEngine(process,
                                 traits,
                                 brownianBridge=False,
                                 antitheticVariate=False,
                                 requiredSamples=None,
                                 requiredTolerance=None,
                                 maxSamples=None,
                                 seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteArithmeticASEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteArithmeticASEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRDiscreteGeometricAPEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteGeometricAPEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRDiscreteGeometricAPEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDiscreteGeometricAPEngine"""
        _QuantLib.MCPRDiscreteGeometricAPEngine_swiginit(self, _QuantLib.new_MCPRDiscreteGeometricAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteGeometricAPEngine

# Register MCPRDiscreteGeometricAPEngine in _QuantLib:
_QuantLib.MCPRDiscreteGeometricAPEngine_swigregister(MCPRDiscreteGeometricAPEngine)
class MCLDDiscreteGeometricAPEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteGeometricAPEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDDiscreteGeometricAPEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDiscreteGeometricAPEngine"""
        _QuantLib.MCLDDiscreteGeometricAPEngine_swiginit(self, _QuantLib.new_MCLDDiscreteGeometricAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteGeometricAPEngine

# Register MCLDDiscreteGeometricAPEngine in _QuantLib:
_QuantLib.MCLDDiscreteGeometricAPEngine_swigregister(MCLDDiscreteGeometricAPEngine)

def MCDiscreteGeometricAPEngine(process,
                                 traits,
                                 brownianBridge=False,
                                 antitheticVariate=False,
                                 requiredSamples=None,
                                 requiredTolerance=None,
                                 maxSamples=None,
                                 seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteGeometricAPEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteGeometricAPEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRDiscreteGeometricAPHestonEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteGeometricAPHestonEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRDiscreteGeometricAPHestonEngine self, ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >()) -> MCPRDiscreteGeometricAPHestonEngine"""
        _QuantLib.MCPRDiscreteGeometricAPHestonEngine_swiginit(self, _QuantLib.new_MCPRDiscreteGeometricAPHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteGeometricAPHestonEngine

# Register MCPRDiscreteGeometricAPHestonEngine in _QuantLib:
_QuantLib.MCPRDiscreteGeometricAPHestonEngine_swigregister(MCPRDiscreteGeometricAPHestonEngine)
class MCLDDiscreteGeometricAPHestonEngine(PricingEngine):
    r"""Proxy of C++ MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDDiscreteGeometricAPHestonEngine self, ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >()) -> MCLDDiscreteGeometricAPHestonEngine"""
        _QuantLib.MCLDDiscreteGeometricAPHestonEngine_swiginit(self, _QuantLib.new_MCLDDiscreteGeometricAPHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteGeometricAPHestonEngine

# Register MCLDDiscreteGeometricAPHestonEngine in _QuantLib:
_QuantLib.MCLDDiscreteGeometricAPHestonEngine_swigregister(MCLDDiscreteGeometricAPHestonEngine)

def MCDiscreteGeometricAPHestonEngine(process,
                                      traits,
                                      antitheticVariate=False,
                                      requiredSamples=None,
                                      requiredTolerance=None,
                                      maxSamples=None,
                                      seed=0,
                                      timeSteps=None,
                                      timeStepsPerYear=None):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteGeometricAPHestonEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteGeometricAPHestonEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               timeSteps,
               timeStepsPerYear)

class ContinuousArithmeticAsianLevyEngine(PricingEngine):
    r"""Proxy of C++ ContinuousArithmeticAsianLevyEngine class."""

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

    def __init__(self, process, runningAverage, startDate):
        r"""__init__(ContinuousArithmeticAsianLevyEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, QuoteHandle runningAverage, Date startDate) -> ContinuousArithmeticAsianLevyEngine"""
        _QuantLib.ContinuousArithmeticAsianLevyEngine_swiginit(self, _QuantLib.new_ContinuousArithmeticAsianLevyEngine(process, runningAverage, startDate))
    __swig_destroy__ = _QuantLib.delete_ContinuousArithmeticAsianLevyEngine

# Register ContinuousArithmeticAsianLevyEngine in _QuantLib:
_QuantLib.ContinuousArithmeticAsianLevyEngine_swigregister(ContinuousArithmeticAsianLevyEngine)
class FdBlackScholesAsianEngine(PricingEngine):
    r"""Proxy of C++ FdBlackScholesAsianEngine class."""

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

    def __init__(self, process, tGrid, xGrid, aGrid):
        r"""__init__(FdBlackScholesAsianEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid, Size xGrid, Size aGrid) -> FdBlackScholesAsianEngine"""
        _QuantLib.FdBlackScholesAsianEngine_swiginit(self, _QuantLib.new_FdBlackScholesAsianEngine(process, tGrid, xGrid, aGrid))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesAsianEngine

# Register FdBlackScholesAsianEngine in _QuantLib:
_QuantLib.FdBlackScholesAsianEngine_swigregister(FdBlackScholesAsianEngine)
class TurnbullWakemanAsianEngine(PricingEngine):
    r"""Proxy of C++ TurnbullWakemanAsianEngine class."""

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

    def __init__(self, process):
        r"""__init__(TurnbullWakemanAsianEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> TurnbullWakemanAsianEngine"""
        _QuantLib.TurnbullWakemanAsianEngine_swiginit(self, _QuantLib.new_TurnbullWakemanAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_TurnbullWakemanAsianEngine

# Register TurnbullWakemanAsianEngine in _QuantLib:
_QuantLib.TurnbullWakemanAsianEngine_swigregister(TurnbullWakemanAsianEngine)
class Barrier(object):
    r"""Proxy of C++ Barrier class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    DownIn = _QuantLib.Barrier_DownIn
    
    UpIn = _QuantLib.Barrier_UpIn
    
    DownOut = _QuantLib.Barrier_DownOut
    
    UpOut = _QuantLib.Barrier_UpOut
    

    def __init__(self):
        r"""__init__(Barrier self) -> Barrier"""
        _QuantLib.Barrier_swiginit(self, _QuantLib.new_Barrier())
    __swig_destroy__ = _QuantLib.delete_Barrier

# Register Barrier in _QuantLib:
_QuantLib.Barrier_swigregister(Barrier)
class BarrierOption(OneAssetOption):
    r"""Proxy of C++ BarrierOption class."""

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

    def __init__(self, barrierType, barrier, rebate, payoff, exercise):
        r"""__init__(BarrierOption self, Barrier::Type barrierType, Real barrier, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> BarrierOption"""
        _QuantLib.BarrierOption_swiginit(self, _QuantLib.new_BarrierOption(barrierType, barrier, rebate, payoff, exercise))

    def impliedVolatility(self, targetValue, process, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-4, maxVol=4.0):
        r"""impliedVolatility(BarrierOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility"""
        return _QuantLib.BarrierOption_impliedVolatility(self, targetValue, process, accuracy, maxEvaluations, minVol, maxVol)
    __swig_destroy__ = _QuantLib.delete_BarrierOption

# Register BarrierOption in _QuantLib:
_QuantLib.BarrierOption_swigregister(BarrierOption)
class QuantoBarrierOption(BarrierOption):
    r"""Proxy of C++ QuantoBarrierOption class."""

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

    def __init__(self, barrierType, barrier, rebate, payoff, exercise):
        r"""__init__(QuantoBarrierOption self, Barrier::Type barrierType, Real barrier, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoBarrierOption"""
        _QuantLib.QuantoBarrierOption_swiginit(self, _QuantLib.new_QuantoBarrierOption(barrierType, barrier, rebate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_QuantoBarrierOption

# Register QuantoBarrierOption in _QuantLib:
_QuantLib.QuantoBarrierOption_swigregister(QuantoBarrierOption)
class PartialBarrier(Barrier):
    r"""Proxy of C++ PartialBarrier class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Start = _QuantLib.PartialBarrier_Start
    
    End = _QuantLib.PartialBarrier_End
    
    EndB1 = _QuantLib.PartialBarrier_EndB1
    
    EndB2 = _QuantLib.PartialBarrier_EndB2
    

    def __init__(self):
        r"""__init__(PartialBarrier self) -> PartialBarrier"""
        _QuantLib.PartialBarrier_swiginit(self, _QuantLib.new_PartialBarrier())
    __swig_destroy__ = _QuantLib.delete_PartialBarrier

# Register PartialBarrier in _QuantLib:
_QuantLib.PartialBarrier_swigregister(PartialBarrier)
class PartialTimeBarrierOption(OneAssetOption):
    r"""Proxy of C++ PartialTimeBarrierOption class."""

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

    def __init__(self, barrierType, barrierRange, barrier, rebate, coverEventDate, payoff, exercise):
        r"""__init__(PartialTimeBarrierOption self, PartialBarrier::Type barrierType, PartialBarrier::Range barrierRange, Real barrier, Real rebate, Date coverEventDate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> PartialTimeBarrierOption"""
        _QuantLib.PartialTimeBarrierOption_swiginit(self, _QuantLib.new_PartialTimeBarrierOption(barrierType, barrierRange, barrier, rebate, coverEventDate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_PartialTimeBarrierOption

# Register PartialTimeBarrierOption in _QuantLib:
_QuantLib.PartialTimeBarrierOption_swigregister(PartialTimeBarrierOption)
class AnalyticPartialTimeBarrierOptionEngine(PricingEngine):
    r"""Partial Time Barrier Option Engine"""

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

    def __init__(self, process):
        r"""
        __init__(AnalyticPartialTimeBarrierOptionEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticPartialTimeBarrierOptionEngine
        Partial Time Barrier Option Engine
        """
        _QuantLib.AnalyticPartialTimeBarrierOptionEngine_swiginit(self, _QuantLib.new_AnalyticPartialTimeBarrierOptionEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticPartialTimeBarrierOptionEngine

# Register AnalyticPartialTimeBarrierOptionEngine in _QuantLib:
_QuantLib.AnalyticPartialTimeBarrierOptionEngine_swigregister(AnalyticPartialTimeBarrierOptionEngine)
class DividendBarrierOption(BarrierOption):
    r"""Proxy of C++ DividendBarrierOption class."""

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

    def __init__(self, barrierType, barrier, rebate, payoff, exercise, dividendDates, dividends):
        r"""__init__(DividendBarrierOption self, Barrier::Type barrierType, Real barrier, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise, DateVector dividendDates, DoubleVector dividends) -> DividendBarrierOption"""
        _QuantLib.DividendBarrierOption_swiginit(self, _QuantLib.new_DividendBarrierOption(barrierType, barrier, rebate, payoff, exercise, dividendDates, dividends))
    __swig_destroy__ = _QuantLib.delete_DividendBarrierOption

# Register DividendBarrierOption in _QuantLib:
_QuantLib.DividendBarrierOption_swigregister(DividendBarrierOption)
class AnalyticBarrierEngine(PricingEngine):
    r"""Proxy of C++ AnalyticBarrierEngine class."""

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

    def __init__(self, arg2):
        r"""__init__(AnalyticBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2) -> AnalyticBarrierEngine"""
        _QuantLib.AnalyticBarrierEngine_swiginit(self, _QuantLib.new_AnalyticBarrierEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_AnalyticBarrierEngine

# Register AnalyticBarrierEngine in _QuantLib:
_QuantLib.AnalyticBarrierEngine_swigregister(AnalyticBarrierEngine)
class MCPRBarrierEngine(PricingEngine):
    r"""Proxy of C++ MCBarrierEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), bool isBiased=False, BigInteger seed=0) -> MCPRBarrierEngine"""
        _QuantLib.MCPRBarrierEngine_swiginit(self, _QuantLib.new_MCPRBarrierEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRBarrierEngine

# Register MCPRBarrierEngine in _QuantLib:
_QuantLib.MCPRBarrierEngine_swigregister(MCPRBarrierEngine)
class MCLDBarrierEngine(PricingEngine):
    r"""Proxy of C++ MCBarrierEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), bool isBiased=False, BigInteger seed=0) -> MCLDBarrierEngine"""
        _QuantLib.MCLDBarrierEngine_swiginit(self, _QuantLib.new_MCLDBarrierEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDBarrierEngine

# Register MCLDBarrierEngine in _QuantLib:
_QuantLib.MCLDBarrierEngine_swigregister(MCLDBarrierEngine)

def MCBarrierEngine(process,
                    traits,
                    timeSteps=None,
                    timeStepsPerYear=None,
                    brownianBridge=False,
                    antitheticVariate=False,
                    requiredSamples=None,
                    requiredTolerance=None,
                    maxSamples=None,
                    isBiased=False,
                    seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRBarrierEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDBarrierEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               isBiased,
               seed)

class QuantoBarrierEngine(PricingEngine):
    r"""Proxy of C++ QuantoBarrierEngine class."""

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

    def __init__(self, arg2, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        r"""__init__(QuantoBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, YieldTermStructureHandle foreignRiskFreeRate, BlackVolTermStructureHandle exchangeRateVolatility, QuoteHandle correlation) -> QuantoBarrierEngine"""
        _QuantLib.QuantoBarrierEngine_swiginit(self, _QuantLib.new_QuantoBarrierEngine(arg2, foreignRiskFreeRate, exchangeRateVolatility, correlation))
    __swig_destroy__ = _QuantLib.delete_QuantoBarrierEngine

# Register QuantoBarrierEngine in _QuantLib:
_QuantLib.QuantoBarrierEngine_swigregister(QuantoBarrierEngine)
class FdBlackScholesBarrierEngine(PricingEngine):
    r"""Proxy of C++ FdBlackScholesBarrierEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdBlackScholesBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >()) -> FdBlackScholesBarrierEngine"""
        _QuantLib.FdBlackScholesBarrierEngine_swiginit(self, _QuantLib.new_FdBlackScholesBarrierEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesBarrierEngine

# Register FdBlackScholesBarrierEngine in _QuantLib:
_QuantLib.FdBlackScholesBarrierEngine_swigregister(FdBlackScholesBarrierEngine)
class FdBlackScholesRebateEngine(PricingEngine):
    r"""Proxy of C++ FdBlackScholesRebateEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdBlackScholesRebateEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >()) -> FdBlackScholesRebateEngine"""
        _QuantLib.FdBlackScholesRebateEngine_swiginit(self, _QuantLib.new_FdBlackScholesRebateEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesRebateEngine

# Register FdBlackScholesRebateEngine in _QuantLib:
_QuantLib.FdBlackScholesRebateEngine_swigregister(FdBlackScholesRebateEngine)
class FdHestonBarrierEngine(PricingEngine):
    r"""Proxy of C++ FdHestonBarrierEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdHestonBarrierEngine self, ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0) -> FdHestonBarrierEngine"""
        _QuantLib.FdHestonBarrierEngine_swiginit(self, _QuantLib.new_FdHestonBarrierEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHestonBarrierEngine

# Register FdHestonBarrierEngine in _QuantLib:
_QuantLib.FdHestonBarrierEngine_swigregister(FdHestonBarrierEngine)
class FdHestonRebateEngine(PricingEngine):
    r"""Proxy of C++ FdHestonRebateEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdHestonRebateEngine self, ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0) -> FdHestonRebateEngine"""
        _QuantLib.FdHestonRebateEngine_swiginit(self, _QuantLib.new_FdHestonRebateEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHestonRebateEngine

# Register FdHestonRebateEngine in _QuantLib:
_QuantLib.FdHestonRebateEngine_swigregister(FdHestonRebateEngine)
class AnalyticBinaryBarrierEngine(PricingEngine):
    r"""Proxy of C++ AnalyticBinaryBarrierEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticBinaryBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticBinaryBarrierEngine"""
        _QuantLib.AnalyticBinaryBarrierEngine_swiginit(self, _QuantLib.new_AnalyticBinaryBarrierEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticBinaryBarrierEngine

# Register AnalyticBinaryBarrierEngine in _QuantLib:
_QuantLib.AnalyticBinaryBarrierEngine_swigregister(AnalyticBinaryBarrierEngine)
class BinomialCRRBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialCRRBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialCRRBarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialCRRBarrierEngine_swiginit(self, _QuantLib.new_BinomialCRRBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRBarrierEngine

# Register BinomialCRRBarrierEngine in _QuantLib:
_QuantLib.BinomialCRRBarrierEngine_swigregister(BinomialCRRBarrierEngine)
class BinomialJRBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialJRBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialJRBarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialJRBarrierEngine_swiginit(self, _QuantLib.new_BinomialJRBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRBarrierEngine

# Register BinomialJRBarrierEngine in _QuantLib:
_QuantLib.BinomialJRBarrierEngine_swigregister(BinomialJRBarrierEngine)
class BinomialEQPBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialEQPBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialEQPBarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialEQPBarrierEngine_swiginit(self, _QuantLib.new_BinomialEQPBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPBarrierEngine

# Register BinomialEQPBarrierEngine in _QuantLib:
_QuantLib.BinomialEQPBarrierEngine_swigregister(BinomialEQPBarrierEngine)
class BinomialTrigeorgisBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialTrigeorgisBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialTrigeorgisBarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialTrigeorgisBarrierEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisBarrierEngine

# Register BinomialTrigeorgisBarrierEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisBarrierEngine_swigregister(BinomialTrigeorgisBarrierEngine)
class BinomialTianBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialTianBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialTianBarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialTianBarrierEngine_swiginit(self, _QuantLib.new_BinomialTianBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianBarrierEngine

# Register BinomialTianBarrierEngine in _QuantLib:
_QuantLib.BinomialTianBarrierEngine_swigregister(BinomialTianBarrierEngine)
class BinomialLRBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialLRBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialLRBarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialLRBarrierEngine_swiginit(self, _QuantLib.new_BinomialLRBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRBarrierEngine

# Register BinomialLRBarrierEngine in _QuantLib:
_QuantLib.BinomialLRBarrierEngine_swigregister(BinomialLRBarrierEngine)
class BinomialJ4BarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

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

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        __init__(BinomialJ4BarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps, Size max_steps=0) -> BinomialJ4BarrierEngine
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialJ4BarrierEngine_swiginit(self, _QuantLib.new_BinomialJ4BarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4BarrierEngine

# Register BinomialJ4BarrierEngine in _QuantLib:
_QuantLib.BinomialJ4BarrierEngine_swigregister(BinomialJ4BarrierEngine)

def BinomialBarrierEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRBarrierEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRBarrierEngine
    elif type == "eqp":
        cls = BinomialEQPBarrierEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisBarrierEngine
    elif type == "tian":
        cls = BinomialTianBarrierEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRBarrierEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4BarrierEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class VannaVolgaBarrierEngine(PricingEngine):
    r"""Proxy of C++ VannaVolgaBarrierEngine class."""

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

    def __init__(self, atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta=False, bsPriceWithSmile=0.0):
        r"""__init__(VannaVolgaBarrierEngine self, DeltaVolQuoteHandle atmVol, DeltaVolQuoteHandle vol25Put, DeltaVolQuoteHandle vol25Call, QuoteHandle spotFX, YieldTermStructureHandle domesticTS, YieldTermStructureHandle foreignTS, bool const adaptVanDelta=False, Real const bsPriceWithSmile=0.0) -> VannaVolgaBarrierEngine"""
        _QuantLib.VannaVolgaBarrierEngine_swiginit(self, _QuantLib.new_VannaVolgaBarrierEngine(atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta, bsPriceWithSmile))
    __swig_destroy__ = _QuantLib.delete_VannaVolgaBarrierEngine

# Register VannaVolgaBarrierEngine in _QuantLib:
_QuantLib.VannaVolgaBarrierEngine_swigregister(VannaVolgaBarrierEngine)
class DoubleBarrier(object):
    r"""Proxy of C++ DoubleBarrier class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    KnockIn = _QuantLib.DoubleBarrier_KnockIn
    
    KnockOut = _QuantLib.DoubleBarrier_KnockOut
    
    KIKO = _QuantLib.DoubleBarrier_KIKO
    
    KOKI = _QuantLib.DoubleBarrier_KOKI
    

    def __init__(self):
        r"""__init__(DoubleBarrier self) -> DoubleBarrier"""
        _QuantLib.DoubleBarrier_swiginit(self, _QuantLib.new_DoubleBarrier())
    __swig_destroy__ = _QuantLib.delete_DoubleBarrier

# Register DoubleBarrier in _QuantLib:
_QuantLib.DoubleBarrier_swigregister(DoubleBarrier)
class DoubleBarrierOption(OneAssetOption):
    r"""Proxy of C++ DoubleBarrierOption class."""

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

    def __init__(self, barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise):
        r"""__init__(DoubleBarrierOption self, DoubleBarrier::Type barrierType, Real barrier_lo, Real barrier_hi, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> DoubleBarrierOption"""
        _QuantLib.DoubleBarrierOption_swiginit(self, _QuantLib.new_DoubleBarrierOption(barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_DoubleBarrierOption

# Register DoubleBarrierOption in _QuantLib:
_QuantLib.DoubleBarrierOption_swigregister(DoubleBarrierOption)
class QuantoDoubleBarrierOption(DoubleBarrierOption):
    r"""Proxy of C++ QuantoDoubleBarrierOption class."""

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

    def __init__(self, barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise):
        r"""__init__(QuantoDoubleBarrierOption self, DoubleBarrier::Type barrierType, Real barrier_lo, Real barrier_hi, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoDoubleBarrierOption"""
        _QuantLib.QuantoDoubleBarrierOption_swiginit(self, _QuantLib.new_QuantoDoubleBarrierOption(barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise))

    def qvega(self):
        r"""qvega(QuantoDoubleBarrierOption self) -> Real"""
        return _QuantLib.QuantoDoubleBarrierOption_qvega(self)

    def qrho(self):
        r"""qrho(QuantoDoubleBarrierOption self) -> Real"""
        return _QuantLib.QuantoDoubleBarrierOption_qrho(self)

    def qlambda(self):
        r"""qlambda(QuantoDoubleBarrierOption self) -> Real"""
        return _QuantLib.QuantoDoubleBarrierOption_qlambda(self)
    __swig_destroy__ = _QuantLib.delete_QuantoDoubleBarrierOption

# Register QuantoDoubleBarrierOption in _QuantLib:
_QuantLib.QuantoDoubleBarrierOption_swigregister(QuantoDoubleBarrierOption)
class AnalyticDoubleBarrierEngine(PricingEngine):
    r"""Double barrier engine implementing Ikeda-Kunitomo series."""

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

    def __init__(self, process, series=5):
        r"""
        __init__(AnalyticDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, int series=5) -> AnalyticDoubleBarrierEngine
        Double barrier engine implementing Ikeda-Kunitomo series.
        """
        _QuantLib.AnalyticDoubleBarrierEngine_swiginit(self, _QuantLib.new_AnalyticDoubleBarrierEngine(process, series))
    __swig_destroy__ = _QuantLib.delete_AnalyticDoubleBarrierEngine

# Register AnalyticDoubleBarrierEngine in _QuantLib:
_QuantLib.AnalyticDoubleBarrierEngine_swigregister(AnalyticDoubleBarrierEngine)
class FdHestonDoubleBarrierEngine(PricingEngine):
    r"""Proxy of C++ FdHestonDoubleBarrierEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdHestonDoubleBarrierEngine self, ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0) -> FdHestonDoubleBarrierEngine"""
        _QuantLib.FdHestonDoubleBarrierEngine_swiginit(self, _QuantLib.new_FdHestonDoubleBarrierEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHestonDoubleBarrierEngine

# Register FdHestonDoubleBarrierEngine in _QuantLib:
_QuantLib.FdHestonDoubleBarrierEngine_swigregister(FdHestonDoubleBarrierEngine)
class SuoWangDoubleBarrierEngine(PricingEngine):
    r"""Proxy of C++ SuoWangDoubleBarrierEngine class."""

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

    def __init__(self, process, series=5):
        r"""__init__(SuoWangDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, int series=5) -> SuoWangDoubleBarrierEngine"""
        _QuantLib.SuoWangDoubleBarrierEngine_swiginit(self, _QuantLib.new_SuoWangDoubleBarrierEngine(process, series))
    __swig_destroy__ = _QuantLib.delete_SuoWangDoubleBarrierEngine

# Register SuoWangDoubleBarrierEngine in _QuantLib:
_QuantLib.SuoWangDoubleBarrierEngine_swigregister(SuoWangDoubleBarrierEngine)

def WulinYongDoubleBarrierEngine(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (WulinYongDoubleBarrierEngine.__name__, SuoWangDoubleBarrierEngine.__name__))
    return SuoWangDoubleBarrierEngine(*args, **kwargs)

class VannaVolgaIKDoubleBarrierEngine(PricingEngine):
    r"""Proxy of C++ VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > class."""

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

    def __init__(self, atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta=False, bsPriceWithSmile=0.0, series=5):
        r"""__init__(VannaVolgaIKDoubleBarrierEngine self, DeltaVolQuoteHandle atmVol, DeltaVolQuoteHandle vol25Put, DeltaVolQuoteHandle vol25Call, QuoteHandle spotFX, YieldTermStructureHandle domesticTS, YieldTermStructureHandle foreignTS, bool const adaptVanDelta=False, Real const bsPriceWithSmile=0.0, int series=5) -> VannaVolgaIKDoubleBarrierEngine"""
        _QuantLib.VannaVolgaIKDoubleBarrierEngine_swiginit(self, _QuantLib.new_VannaVolgaIKDoubleBarrierEngine(atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta, bsPriceWithSmile, series))
    __swig_destroy__ = _QuantLib.delete_VannaVolgaIKDoubleBarrierEngine

# Register VannaVolgaIKDoubleBarrierEngine in _QuantLib:
_QuantLib.VannaVolgaIKDoubleBarrierEngine_swigregister(VannaVolgaIKDoubleBarrierEngine)
class VannaVolgaWODoubleBarrierEngine(PricingEngine):
    r"""Proxy of C++ VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > class."""

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

    def __init__(self, atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta=False, bsPriceWithSmile=0.0, series=5):
        r"""__init__(VannaVolgaWODoubleBarrierEngine self, DeltaVolQuoteHandle atmVol, DeltaVolQuoteHandle vol25Put, DeltaVolQuoteHandle vol25Call, QuoteHandle spotFX, YieldTermStructureHandle domesticTS, YieldTermStructureHandle foreignTS, bool const adaptVanDelta=False, Real const bsPriceWithSmile=0.0, int series=5) -> VannaVolgaWODoubleBarrierEngine"""
        _QuantLib.VannaVolgaWODoubleBarrierEngine_swiginit(self, _QuantLib.new_VannaVolgaWODoubleBarrierEngine(atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta, bsPriceWithSmile, series))
    __swig_destroy__ = _QuantLib.delete_VannaVolgaWODoubleBarrierEngine

# Register VannaVolgaWODoubleBarrierEngine in _QuantLib:
_QuantLib.VannaVolgaWODoubleBarrierEngine_swigregister(VannaVolgaWODoubleBarrierEngine)
class AnalyticDoubleBarrierBinaryEngine(PricingEngine):
    r"""Proxy of C++ AnalyticDoubleBarrierBinaryEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticDoubleBarrierBinaryEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDoubleBarrierBinaryEngine"""
        _QuantLib.AnalyticDoubleBarrierBinaryEngine_swiginit(self, _QuantLib.new_AnalyticDoubleBarrierBinaryEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDoubleBarrierBinaryEngine

# Register AnalyticDoubleBarrierBinaryEngine in _QuantLib:
_QuantLib.AnalyticDoubleBarrierBinaryEngine_swigregister(AnalyticDoubleBarrierBinaryEngine)
class BinomialCRRDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialCRRDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialCRRDoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialCRRDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialCRRDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRDoubleBarrierEngine

# Register BinomialCRRDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialCRRDoubleBarrierEngine_swigregister(BinomialCRRDoubleBarrierEngine)
class BinomialJRDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialJRDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialJRDoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialJRDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialJRDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRDoubleBarrierEngine

# Register BinomialJRDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialJRDoubleBarrierEngine_swigregister(BinomialJRDoubleBarrierEngine)
class BinomialEQPDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialEQPDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialEQPDoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialEQPDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialEQPDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPDoubleBarrierEngine

# Register BinomialEQPDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialEQPDoubleBarrierEngine_swigregister(BinomialEQPDoubleBarrierEngine)
class BinomialTrigeorgisDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialTrigeorgisDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialTrigeorgisDoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialTrigeorgisDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisDoubleBarrierEngine

# Register BinomialTrigeorgisDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisDoubleBarrierEngine_swigregister(BinomialTrigeorgisDoubleBarrierEngine)
class BinomialTianDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialTianDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialTianDoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialTianDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialTianDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianDoubleBarrierEngine

# Register BinomialTianDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialTianDoubleBarrierEngine_swigregister(BinomialTianDoubleBarrierEngine)
class BinomialLRDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialLRDoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialLRDoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialLRDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialLRDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRDoubleBarrierEngine

# Register BinomialLRDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialLRDoubleBarrierEngine_swigregister(BinomialLRDoubleBarrierEngine)
class BinomialJ4DoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

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

    def __init__(self, arg2, steps):
        r"""
        __init__(BinomialJ4DoubleBarrierEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, Size steps) -> BinomialJ4DoubleBarrierEngine
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialJ4DoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialJ4DoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4DoubleBarrierEngine

# Register BinomialJ4DoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialJ4DoubleBarrierEngine_swigregister(BinomialJ4DoubleBarrierEngine)

def BinomialDoubleBarrierEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRDoubleBarrierEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRDoubleBarrierEngine
    elif type == "eqp":
        cls = BinomialEQPDoubleBarrierEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisDoubleBarrierEngine
    elif type == "tian":
        cls = BinomialTianDoubleBarrierEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRDoubleBarrierEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4DoubleBarrierEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class PlainVanillaPayoff(StrikedTypePayoff):
    r"""Proxy of C++ PlainVanillaPayoff class."""

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

    def __init__(self, type, strike):
        r"""__init__(PlainVanillaPayoff self, Option::Type type, Real strike) -> PlainVanillaPayoff"""
        _QuantLib.PlainVanillaPayoff_swiginit(self, _QuantLib.new_PlainVanillaPayoff(type, strike))
    __swig_destroy__ = _QuantLib.delete_PlainVanillaPayoff

# Register PlainVanillaPayoff in _QuantLib:
_QuantLib.PlainVanillaPayoff_swigregister(PlainVanillaPayoff)

def as_plain_vanilla_payoff(payoff):
    r"""as_plain_vanilla_payoff(ext::shared_ptr< Payoff > const & payoff) -> ext::shared_ptr< PlainVanillaPayoff > const"""
    return _QuantLib.as_plain_vanilla_payoff(payoff)
class PercentageStrikePayoff(StrikedTypePayoff):
    r"""Proxy of C++ PercentageStrikePayoff class."""

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

    def __init__(self, type, moneyness):
        r"""__init__(PercentageStrikePayoff self, Option::Type type, Real moneyness) -> PercentageStrikePayoff"""
        _QuantLib.PercentageStrikePayoff_swiginit(self, _QuantLib.new_PercentageStrikePayoff(type, moneyness))
    __swig_destroy__ = _QuantLib.delete_PercentageStrikePayoff

# Register PercentageStrikePayoff in _QuantLib:
_QuantLib.PercentageStrikePayoff_swigregister(PercentageStrikePayoff)
class CashOrNothingPayoff(StrikedTypePayoff):
    r"""Proxy of C++ CashOrNothingPayoff class."""

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

    def __init__(self, type, strike, payoff):
        r"""__init__(CashOrNothingPayoff self, Option::Type type, Real strike, Real payoff) -> CashOrNothingPayoff"""
        _QuantLib.CashOrNothingPayoff_swiginit(self, _QuantLib.new_CashOrNothingPayoff(type, strike, payoff))
    __swig_destroy__ = _QuantLib.delete_CashOrNothingPayoff

# Register CashOrNothingPayoff in _QuantLib:
_QuantLib.CashOrNothingPayoff_swigregister(CashOrNothingPayoff)
class AssetOrNothingPayoff(StrikedTypePayoff):
    r"""Proxy of C++ AssetOrNothingPayoff class."""

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

    def __init__(self, type, strike):
        r"""__init__(AssetOrNothingPayoff self, Option::Type type, Real strike) -> AssetOrNothingPayoff"""
        _QuantLib.AssetOrNothingPayoff_swiginit(self, _QuantLib.new_AssetOrNothingPayoff(type, strike))
    __swig_destroy__ = _QuantLib.delete_AssetOrNothingPayoff

# Register AssetOrNothingPayoff in _QuantLib:
_QuantLib.AssetOrNothingPayoff_swigregister(AssetOrNothingPayoff)
class SuperSharePayoff(StrikedTypePayoff):
    r"""Proxy of C++ SuperSharePayoff class."""

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

    def __init__(self, type, strike, increment):
        r"""__init__(SuperSharePayoff self, Option::Type type, Real strike, Real increment) -> SuperSharePayoff"""
        _QuantLib.SuperSharePayoff_swiginit(self, _QuantLib.new_SuperSharePayoff(type, strike, increment))
    __swig_destroy__ = _QuantLib.delete_SuperSharePayoff

# Register SuperSharePayoff in _QuantLib:
_QuantLib.SuperSharePayoff_swigregister(SuperSharePayoff)
class GapPayoff(StrikedTypePayoff):
    r"""Proxy of C++ GapPayoff class."""

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

    def __init__(self, type, strike, strikePayoff):
        r"""__init__(GapPayoff self, Option::Type type, Real strike, Real strikePayoff) -> GapPayoff"""
        _QuantLib.GapPayoff_swiginit(self, _QuantLib.new_GapPayoff(type, strike, strikePayoff))
    __swig_destroy__ = _QuantLib.delete_GapPayoff

# Register GapPayoff in _QuantLib:
_QuantLib.GapPayoff_swigregister(GapPayoff)
class VanillaForwardPayoff(StrikedTypePayoff):
    r"""Proxy of C++ VanillaForwardPayoff class."""

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

    def __init__(self, type, strike):
        r"""__init__(VanillaForwardPayoff self, Option::Type type, Real strike) -> VanillaForwardPayoff"""
        _QuantLib.VanillaForwardPayoff_swiginit(self, _QuantLib.new_VanillaForwardPayoff(type, strike))
    __swig_destroy__ = _QuantLib.delete_VanillaForwardPayoff

# Register VanillaForwardPayoff in _QuantLib:
_QuantLib.VanillaForwardPayoff_swigregister(VanillaForwardPayoff)
class BasketPayoff(Payoff):
    r"""Proxy of C++ BasketPayoff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register BasketPayoff in _QuantLib:
_QuantLib.BasketPayoff_swigregister(BasketPayoff)
class MinBasketPayoff(BasketPayoff):
    r"""Proxy of C++ MinBasketPayoff class."""

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

    def __init__(self, p):
        r"""__init__(MinBasketPayoff self, ext::shared_ptr< Payoff > const p) -> MinBasketPayoff"""
        _QuantLib.MinBasketPayoff_swiginit(self, _QuantLib.new_MinBasketPayoff(p))
    __swig_destroy__ = _QuantLib.delete_MinBasketPayoff

# Register MinBasketPayoff in _QuantLib:
_QuantLib.MinBasketPayoff_swigregister(MinBasketPayoff)
class MaxBasketPayoff(BasketPayoff):
    r"""Proxy of C++ MaxBasketPayoff class."""

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

    def __init__(self, p):
        r"""__init__(MaxBasketPayoff self, ext::shared_ptr< Payoff > const p) -> MaxBasketPayoff"""
        _QuantLib.MaxBasketPayoff_swiginit(self, _QuantLib.new_MaxBasketPayoff(p))
    __swig_destroy__ = _QuantLib.delete_MaxBasketPayoff

# Register MaxBasketPayoff in _QuantLib:
_QuantLib.MaxBasketPayoff_swigregister(MaxBasketPayoff)
class AverageBasketPayoff(BasketPayoff):
    r"""Proxy of C++ AverageBasketPayoff class."""

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

    def __init__(self, *args):
        r"""
        __init__(AverageBasketPayoff self, ext::shared_ptr< Payoff > const p, Array a) -> AverageBasketPayoff
        __init__(AverageBasketPayoff self, ext::shared_ptr< Payoff > const p, Size n) -> AverageBasketPayoff
        """
        _QuantLib.AverageBasketPayoff_swiginit(self, _QuantLib.new_AverageBasketPayoff(*args))
    __swig_destroy__ = _QuantLib.delete_AverageBasketPayoff

# Register AverageBasketPayoff in _QuantLib:
_QuantLib.AverageBasketPayoff_swigregister(AverageBasketPayoff)
class SpreadBasketPayoff(BasketPayoff):
    r"""Proxy of C++ SpreadBasketPayoff class."""

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

    def __init__(self, p):
        r"""__init__(SpreadBasketPayoff self, ext::shared_ptr< Payoff > const p) -> SpreadBasketPayoff"""
        _QuantLib.SpreadBasketPayoff_swiginit(self, _QuantLib.new_SpreadBasketPayoff(p))
    __swig_destroy__ = _QuantLib.delete_SpreadBasketPayoff

# Register SpreadBasketPayoff in _QuantLib:
_QuantLib.SpreadBasketPayoff_swigregister(SpreadBasketPayoff)
class BasketOption(MultiAssetOption):
    r"""Proxy of C++ BasketOption class."""

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

    def __init__(self, payoff, exercise):
        r"""__init__(BasketOption self, ext::shared_ptr< BasketPayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> BasketOption"""
        _QuantLib.BasketOption_swiginit(self, _QuantLib.new_BasketOption(payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_BasketOption

# Register BasketOption in _QuantLib:
_QuantLib.BasketOption_swigregister(BasketOption)
class MCPREuropeanBasketEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanBasketEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPREuropeanBasketEngine self, ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanBasketEngine"""
        _QuantLib.MCPREuropeanBasketEngine_swiginit(self, _QuantLib.new_MCPREuropeanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanBasketEngine

# Register MCPREuropeanBasketEngine in _QuantLib:
_QuantLib.MCPREuropeanBasketEngine_swigregister(MCPREuropeanBasketEngine)
class MCLDEuropeanBasketEngine(PricingEngine):
    r"""Proxy of C++ MCEuropeanBasketEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDEuropeanBasketEngine self, ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanBasketEngine"""
        _QuantLib.MCLDEuropeanBasketEngine_swiginit(self, _QuantLib.new_MCLDEuropeanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanBasketEngine

# Register MCLDEuropeanBasketEngine in _QuantLib:
_QuantLib.MCLDEuropeanBasketEngine_swigregister(MCLDEuropeanBasketEngine)

def MCEuropeanBasketEngine(process,
                           traits,
                           timeSteps=None,
                           timeStepsPerYear=None,
                           brownianBridge=False,
                           antitheticVariate=False,
                           requiredSamples=None,
                           requiredTolerance=None,
                           maxSamples=None,
                           seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanBasketEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanBasketEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRAmericanBasketEngine(PricingEngine):
    r"""Proxy of C++ MCAmericanBasketEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRAmericanBasketEngine self, ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, Size nCalibrationSamples=Null< Size >(), Size polynomOrder=2, LsmBasisSystem::PolynomType polynomType=Monomial) -> MCPRAmericanBasketEngine"""
        _QuantLib.MCPRAmericanBasketEngine_swiginit(self, _QuantLib.new_MCPRAmericanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRAmericanBasketEngine

# Register MCPRAmericanBasketEngine in _QuantLib:
_QuantLib.MCPRAmericanBasketEngine_swigregister(MCPRAmericanBasketEngine)
class MCLDAmericanBasketEngine(PricingEngine):
    r"""Proxy of C++ MCAmericanBasketEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDAmericanBasketEngine self, ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, Size nCalibrationSamples=Null< Size >(), Size polynomOrder=2, LsmBasisSystem::PolynomType polynomType=Monomial) -> MCLDAmericanBasketEngine"""
        _QuantLib.MCLDAmericanBasketEngine_swiginit(self, _QuantLib.new_MCLDAmericanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDAmericanBasketEngine

# Register MCLDAmericanBasketEngine in _QuantLib:
_QuantLib.MCLDAmericanBasketEngine_swigregister(MCLDAmericanBasketEngine)

def MCAmericanBasketEngine(process,
                           traits,
                           timeSteps=None,
                           timeStepsPerYear=None,
                           brownianBridge=False,
                           antitheticVariate=False,
                           requiredSamples=None,
                           requiredTolerance=None,
                           maxSamples=None,
                           seed=0,
                           nCalibrationSamples=2048,
                           polynomOrder=2,
                           polynomType=LsmBasisSystem.Monomial):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRAmericanBasketEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDAmericanBasketEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               nCalibrationSamples,
               polynomOrder,
               polynomType)

class StulzEngine(PricingEngine):
    r"""Proxy of C++ StulzEngine class."""

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

    def __init__(self, process1, process2, correlation):
        r"""__init__(StulzEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process2, Real correlation) -> StulzEngine"""
        _QuantLib.StulzEngine_swiginit(self, _QuantLib.new_StulzEngine(process1, process2, correlation))
    __swig_destroy__ = _QuantLib.delete_StulzEngine

# Register StulzEngine in _QuantLib:
_QuantLib.StulzEngine_swigregister(StulzEngine)
class KirkEngine(PricingEngine):
    r"""Proxy of C++ KirkEngine class."""

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

    def __init__(self, process1, process2, correlation):
        r"""__init__(KirkEngine self, ext::shared_ptr< BlackProcess > const & process1, ext::shared_ptr< BlackProcess > const & process2, Real correlation) -> KirkEngine"""
        _QuantLib.KirkEngine_swiginit(self, _QuantLib.new_KirkEngine(process1, process2, correlation))
    __swig_destroy__ = _QuantLib.delete_KirkEngine

# Register KirkEngine in _QuantLib:
_QuantLib.KirkEngine_swigregister(KirkEngine)
class Fd2dBlackScholesVanillaEngine(PricingEngine):
    r"""Proxy of C++ Fd2dBlackScholesVanillaEngine class."""

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

    def __init__(self, *args):
        r"""__init__(Fd2dBlackScholesVanillaEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p2, Real correlation, Size xGrid=100, Size yGrid=100, Size tGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >()) -> Fd2dBlackScholesVanillaEngine"""
        _QuantLib.Fd2dBlackScholesVanillaEngine_swiginit(self, _QuantLib.new_Fd2dBlackScholesVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Fd2dBlackScholesVanillaEngine

# Register Fd2dBlackScholesVanillaEngine in _QuantLib:
_QuantLib.Fd2dBlackScholesVanillaEngine_swigregister(Fd2dBlackScholesVanillaEngine)
class EverestOption(MultiAssetOption):
    r"""Proxy of C++ EverestOption class."""

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

    def __init__(self, notional, guarantee, exercise):
        r"""__init__(EverestOption self, Real notional, Rate guarantee, ext::shared_ptr< Exercise > const & exercise) -> EverestOption"""
        _QuantLib.EverestOption_swiginit(self, _QuantLib.new_EverestOption(notional, guarantee, exercise))
    __swig_destroy__ = _QuantLib.delete_EverestOption

# Register EverestOption in _QuantLib:
_QuantLib.EverestOption_swigregister(EverestOption)
class MCPREverestEngine(PricingEngine):
    r"""Proxy of C++ MCEverestEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPREverestEngine self, ext::shared_ptr< StochasticProcessArray > const & process, Size timeSteps=Null< Size >(), Size timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREverestEngine"""
        _QuantLib.MCPREverestEngine_swiginit(self, _QuantLib.new_MCPREverestEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREverestEngine

# Register MCPREverestEngine in _QuantLib:
_QuantLib.MCPREverestEngine_swigregister(MCPREverestEngine)
class MCLDEverestEngine(PricingEngine):
    r"""Proxy of C++ MCEverestEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDEverestEngine self, ext::shared_ptr< StochasticProcessArray > const & process, Size timeSteps=Null< Size >(), Size timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEverestEngine"""
        _QuantLib.MCLDEverestEngine_swiginit(self, _QuantLib.new_MCLDEverestEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEverestEngine

# Register MCLDEverestEngine in _QuantLib:
_QuantLib.MCLDEverestEngine_swigregister(MCLDEverestEngine)

def MCEverestEngine(process,
                    traits,
                    timeSteps=None,
                    timeStepsPerYear=None,
                    brownianBridge=False,
                    antitheticVariate=False,
                    requiredSamples=None,
                    requiredTolerance=None,
                    maxSamples=None,
                    seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREverestEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEverestEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class HimalayaOption(MultiAssetOption):
    r"""Proxy of C++ HimalayaOption class."""

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

    def __init__(self, fixingDates, strike):
        r"""__init__(HimalayaOption self, DateVector fixingDates, Real strike) -> HimalayaOption"""
        _QuantLib.HimalayaOption_swiginit(self, _QuantLib.new_HimalayaOption(fixingDates, strike))
    __swig_destroy__ = _QuantLib.delete_HimalayaOption

# Register HimalayaOption in _QuantLib:
_QuantLib.HimalayaOption_swigregister(HimalayaOption)
class MCPRHimalayaEngine(PricingEngine):
    r"""Proxy of C++ MCHimalayaEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRHimalayaEngine self, ext::shared_ptr< StochasticProcessArray > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRHimalayaEngine"""
        _QuantLib.MCPRHimalayaEngine_swiginit(self, _QuantLib.new_MCPRHimalayaEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRHimalayaEngine

# Register MCPRHimalayaEngine in _QuantLib:
_QuantLib.MCPRHimalayaEngine_swigregister(MCPRHimalayaEngine)
class MCLDHimalayaEngine(PricingEngine):
    r"""Proxy of C++ MCHimalayaEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDHimalayaEngine self, ext::shared_ptr< StochasticProcessArray > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDHimalayaEngine"""
        _QuantLib.MCLDHimalayaEngine_swiginit(self, _QuantLib.new_MCLDHimalayaEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDHimalayaEngine

# Register MCLDHimalayaEngine in _QuantLib:
_QuantLib.MCLDHimalayaEngine_swigregister(MCLDHimalayaEngine)

def MCHimalayaEngine(process,
                     traits,
                     brownianBridge=False,
                     antitheticVariate=False,
                     requiredSamples=None,
                     requiredTolerance=None,
                     maxSamples=None,
                     seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRHimalayaEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDHimalayaEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)


def blackFormula(optionType, strike, forward, stdDev, discount=1.0, displacement=0.0):
    r"""blackFormula(Option::Type optionType, Real strike, Real forward, Real stdDev, Real discount=1.0, Real displacement=0.0) -> Real"""
    return _QuantLib.blackFormula(optionType, strike, forward, stdDev, discount, displacement)

def blackFormulaImpliedStdDev(*args):
    r"""blackFormulaImpliedStdDev(Option::Type optionType, Real strike, Real forward, Real blackPrice, Real discount=1.0, Real displacement=0.0, Real guess=Null< Real >(), Real accuracy=1.0e-6, Natural maxIterations=100) -> Real"""
    return _QuantLib.blackFormulaImpliedStdDev(*args)

def blackFormulaImpliedStdDevLiRS(*args):
    r"""
    blackFormulaImpliedStdDevLiRS(Option::Type optionType, Real strike, Real forward, Real blackPrice, Real discount=1.0, Real displacement=0.0, Real guess=Null< Real >(), Real omega=1.0, Real accuracy=1.0e-6, Natural maxIterations=100) -> Real
    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real blackPrice, Real discount=1.0, Real displacement=0.0, Real guess=Null< Real >(), Real omega=1.0, Real accuracy=1.0e-6, Natural maxIterations=100) -> Real
    """
    return _QuantLib.blackFormulaImpliedStdDevLiRS(*args)

def blackFormulaCashItmProbability(*args):
    r"""
    blackFormulaCashItmProbability(Option::Type optionType, Real strike, Real forward, Real stdDev, Real displacement=0.0) -> Real
    blackFormulaCashItmProbability(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real stdDev, Real displacement=0.0) -> Real
    """
    return _QuantLib.blackFormulaCashItmProbability(*args)

def blackFormulaAssetItmProbability(*args):
    r"""
    blackFormulaAssetItmProbability(Option::Type optionType, Real strike, Real forward, Real stdDev, Real displacement=0.0) -> Real
    blackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real stdDev, Real displacement=0.0) -> Real
    """
    return _QuantLib.blackFormulaAssetItmProbability(*args)

def bachelierBlackFormula(optionType, strike, forward, stdDev, discount=1.0):
    r"""bachelierBlackFormula(Option::Type optionType, Real strike, Real forward, Real stdDev, Real discount=1.0) -> Real"""
    return _QuantLib.bachelierBlackFormula(optionType, strike, forward, stdDev, discount)

def bachelierBlackFormulaImpliedVol(optionType, strike, forward, tte, bachelierPrice, discount=1.0):
    r"""bachelierBlackFormulaImpliedVol(Option::Type optionType, Real strike, Real forward, Real tte, Real bachelierPrice, Real discount=1.0) -> Real"""
    return _QuantLib.bachelierBlackFormulaImpliedVol(optionType, strike, forward, tte, bachelierPrice, discount)

def bachelierBlackFormulaAssetItmProbability(*args):
    r"""
    bachelierBlackFormulaAssetItmProbability(Option::Type optionType, Real strike, Real forward, Real stdDev) -> Real
    bachelierBlackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real stdDev) -> Real
    """
    return _QuantLib.bachelierBlackFormulaAssetItmProbability(*args)
class BlackDeltaCalculator(object):
    r"""Proxy of C++ BlackDeltaCalculator class."""

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

    def __init__(self, ot, dt, spot, dDiscount, fDiscount, stDev):
        r"""__init__(BlackDeltaCalculator self, Option::Type ot, DeltaVolQuote::DeltaType dt, Real spot, DiscountFactor dDiscount, DiscountFactor fDiscount, Real stDev) -> BlackDeltaCalculator"""
        _QuantLib.BlackDeltaCalculator_swiginit(self, _QuantLib.new_BlackDeltaCalculator(ot, dt, spot, dDiscount, fDiscount, stDev))

    def deltaFromStrike(self, strike):
        r"""deltaFromStrike(BlackDeltaCalculator self, Real strike) -> Real"""
        return _QuantLib.BlackDeltaCalculator_deltaFromStrike(self, strike)

    def strikeFromDelta(self, delta):
        r"""strikeFromDelta(BlackDeltaCalculator self, Real delta) -> Real"""
        return _QuantLib.BlackDeltaCalculator_strikeFromDelta(self, delta)

    def atmStrike(self, atmT):
        r"""atmStrike(BlackDeltaCalculator self, DeltaVolQuote::AtmType atmT) -> Real"""
        return _QuantLib.BlackDeltaCalculator_atmStrike(self, atmT)
    __swig_destroy__ = _QuantLib.delete_BlackDeltaCalculator

# Register BlackDeltaCalculator in _QuantLib:
_QuantLib.BlackDeltaCalculator_swigregister(BlackDeltaCalculator)
class TimeBasket(object):
    r"""Proxy of C++ TimeBasket class."""

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

    def __init__(self, *args):
        r"""
        __init__(TimeBasket self) -> TimeBasket
        __init__(TimeBasket self, DateVector arg2, DoubleVector arg3) -> TimeBasket
        """
        _QuantLib.TimeBasket_swiginit(self, _QuantLib.new_TimeBasket(*args))

    def __len__(self):
        r"""__len__(TimeBasket self) -> Size"""
        return _QuantLib.TimeBasket___len__(self)

    def rebin(self, arg2):
        r"""rebin(TimeBasket self, DateVector arg2) -> TimeBasket"""
        return _QuantLib.TimeBasket_rebin(self, arg2)

    def __getitem__(self, d):
        r"""__getitem__(TimeBasket self, Date d) -> Real"""
        return _QuantLib.TimeBasket___getitem__(self, d)

    def __setitem__(self, d, value):
        r"""__setitem__(TimeBasket self, Date d, Real value)"""
        return _QuantLib.TimeBasket___setitem__(self, d, value)

    def items(self):
        r"""items(TimeBasket self) -> PyObject *"""
        return _QuantLib.TimeBasket_items(self)

    def __contains__(self, d):
        r"""__contains__(TimeBasket self, Date d) -> bool"""
        return _QuantLib.TimeBasket___contains__(self, d)

    def __iter__(self):
        r"""__iter__(TimeBasket self) -> PyObject *"""
        return _QuantLib.TimeBasket___iter__(self)
    __swig_destroy__ = _QuantLib.delete_TimeBasket

# Register TimeBasket in _QuantLib:
_QuantLib.TimeBasket_swigregister(TimeBasket)
class Swap(Instrument):
    r"""Proxy of C++ Swap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Receiver = _QuantLib.Swap_Receiver
    
    Payer = _QuantLib.Swap_Payer
    

    def __init__(self, *args):
        r"""
        __init__(Swap self, Leg firstLeg, Leg secondLeg) -> Swap
        __init__(Swap self, LegVector legs, BoolVector payer) -> Swap
        """
        _QuantLib.Swap_swiginit(self, _QuantLib.new_Swap(*args))

    def startDate(self):
        r"""startDate(Swap self) -> Date"""
        return _QuantLib.Swap_startDate(self)

    def maturityDate(self):
        r"""maturityDate(Swap self) -> Date"""
        return _QuantLib.Swap_maturityDate(self)

    def leg(self, i):
        r"""leg(Swap self, Size i) -> Leg"""
        return _QuantLib.Swap_leg(self, i)

    def legNPV(self, j):
        r"""legNPV(Swap self, Size j) -> Real"""
        return _QuantLib.Swap_legNPV(self, j)

    def legBPS(self, k):
        r"""legBPS(Swap self, Size k) -> Real"""
        return _QuantLib.Swap_legBPS(self, k)
    __swig_destroy__ = _QuantLib.delete_Swap

# Register Swap in _QuantLib:
_QuantLib.Swap_swigregister(Swap)
class VanillaSwap(Swap):
    r"""Proxy of C++ VanillaSwap class."""

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

    def __init__(self, *args):
        r"""__init__(VanillaSwap self, Swap::Type type, Real nominal, Schedule fixedSchedule, Rate fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, ext::shared_ptr< IborIndex > const & index, Spread spread, DayCounter floatingDayCount, boost::optional< bool > withIndexedCoupons=boost::none) -> VanillaSwap"""
        _QuantLib.VanillaSwap_swiginit(self, _QuantLib.new_VanillaSwap(*args))

    def type(self):
        r"""type(VanillaSwap self) -> Swap::Type"""
        return _QuantLib.VanillaSwap_type(self)

    def fairRate(self):
        r"""fairRate(VanillaSwap self) -> Rate"""
        return _QuantLib.VanillaSwap_fairRate(self)

    def fairSpread(self):
        r"""fairSpread(VanillaSwap self) -> Spread"""
        return _QuantLib.VanillaSwap_fairSpread(self)

    def fixedLegBPS(self):
        r"""fixedLegBPS(VanillaSwap self) -> Real"""
        return _QuantLib.VanillaSwap_fixedLegBPS(self)

    def floatingLegBPS(self):
        r"""floatingLegBPS(VanillaSwap self) -> Real"""
        return _QuantLib.VanillaSwap_floatingLegBPS(self)

    def fixedLegNPV(self):
        r"""fixedLegNPV(VanillaSwap self) -> Real"""
        return _QuantLib.VanillaSwap_fixedLegNPV(self)

    def floatingLegNPV(self):
        r"""floatingLegNPV(VanillaSwap self) -> Real"""
        return _QuantLib.VanillaSwap_floatingLegNPV(self)

    def fixedLeg(self):
        r"""fixedLeg(VanillaSwap self) -> Leg"""
        return _QuantLib.VanillaSwap_fixedLeg(self)

    def floatingLeg(self):
        r"""floatingLeg(VanillaSwap self) -> Leg"""
        return _QuantLib.VanillaSwap_floatingLeg(self)

    def nominal(self):
        r"""nominal(VanillaSwap self) -> Real"""
        return _QuantLib.VanillaSwap_nominal(self)

    def fixedSchedule(self):
        r"""fixedSchedule(VanillaSwap self) -> Schedule"""
        return _QuantLib.VanillaSwap_fixedSchedule(self)

    def floatingSchedule(self):
        r"""floatingSchedule(VanillaSwap self) -> Schedule"""
        return _QuantLib.VanillaSwap_floatingSchedule(self)

    def fixedRate(self):
        r"""fixedRate(VanillaSwap self) -> Rate"""
        return _QuantLib.VanillaSwap_fixedRate(self)

    def spread(self):
        r"""spread(VanillaSwap self) -> Spread"""
        return _QuantLib.VanillaSwap_spread(self)

    def floatingDayCount(self):
        r"""floatingDayCount(VanillaSwap self) -> DayCounter"""
        return _QuantLib.VanillaSwap_floatingDayCount(self)

    def fixedDayCount(self):
        r"""fixedDayCount(VanillaSwap self) -> DayCounter"""
        return _QuantLib.VanillaSwap_fixedDayCount(self)
    __swig_destroy__ = _QuantLib.delete_VanillaSwap

# Register VanillaSwap in _QuantLib:
_QuantLib.VanillaSwap_swigregister(VanillaSwap)
class _MakeVanillaSwap(object):
    r"""Proxy of C++ MakeVanillaSwap class."""

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

    def receiveFixed(self, flag=True):
        r"""receiveFixed(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_receiveFixed(self, flag)

    def withType(self, type):
        r"""withType(_MakeVanillaSwap self, Swap::Type type) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withType(self, type)

    def withNominal(self, n):
        r"""withNominal(_MakeVanillaSwap self, Real n) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withNominal(self, n)

    def withSettlementDays(self, settlementDays):
        r"""withSettlementDays(_MakeVanillaSwap self, Natural settlementDays) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withSettlementDays(self, settlementDays)

    def withEffectiveDate(self, arg2):
        r"""withEffectiveDate(_MakeVanillaSwap self, Date arg2) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withEffectiveDate(self, arg2)

    def withTerminationDate(self, arg2):
        r"""withTerminationDate(_MakeVanillaSwap self, Date arg2) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withTerminationDate(self, arg2)

    def withRule(self, r):
        r"""withRule(_MakeVanillaSwap self, DateGeneration::Rule r) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withRule(self, r)

    def withFixedLegTenor(self, t):
        r"""withFixedLegTenor(_MakeVanillaSwap self, Period t) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegTenor(self, t)

    def withFixedLegCalendar(self, cal):
        r"""withFixedLegCalendar(_MakeVanillaSwap self, Calendar cal) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegCalendar(self, cal)

    def withFixedLegConvention(self, bdc):
        r"""withFixedLegConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegConvention(self, bdc)

    def withFixedLegTerminationDateConvention(self, bdc):
        r"""withFixedLegTerminationDateConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegTerminationDateConvention(self, bdc)

    def withFixedLegRule(self, r):
        r"""withFixedLegRule(_MakeVanillaSwap self, DateGeneration::Rule r) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegRule(self, r)

    def withFixedLegEndOfMonth(self, flag=True):
        r"""withFixedLegEndOfMonth(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegEndOfMonth(self, flag)

    def withFixedLegFirstDate(self, d):
        r"""withFixedLegFirstDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegFirstDate(self, d)

    def withFixedLegNextToLastDate(self, d):
        r"""withFixedLegNextToLastDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegNextToLastDate(self, d)

    def withFixedLegDayCount(self, dc):
        r"""withFixedLegDayCount(_MakeVanillaSwap self, DayCounter dc) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFixedLegDayCount(self, dc)

    def withFloatingLegTenor(self, t):
        r"""withFloatingLegTenor(_MakeVanillaSwap self, Period t) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegTenor(self, t)

    def withFloatingLegCalendar(self, cal):
        r"""withFloatingLegCalendar(_MakeVanillaSwap self, Calendar cal) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegCalendar(self, cal)

    def withFloatingLegConvention(self, bdc):
        r"""withFloatingLegConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegConvention(self, bdc)

    def withFloatingLegTerminationDateConvention(self, bdc):
        r"""withFloatingLegTerminationDateConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegTerminationDateConvention(self, bdc)

    def withFloatingLegRule(self, r):
        r"""withFloatingLegRule(_MakeVanillaSwap self, DateGeneration::Rule r) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegRule(self, r)

    def withFloatingLegEndOfMonth(self, flag=True):
        r"""withFloatingLegEndOfMonth(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegEndOfMonth(self, flag)

    def withFloatingLegFirstDate(self, d):
        r"""withFloatingLegFirstDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegFirstDate(self, d)

    def withFloatingLegNextToLastDate(self, d):
        r"""withFloatingLegNextToLastDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegNextToLastDate(self, d)

    def withFloatingLegDayCount(self, dc):
        r"""withFloatingLegDayCount(_MakeVanillaSwap self, DayCounter dc) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegDayCount(self, dc)

    def withFloatingLegSpread(self, sp):
        r"""withFloatingLegSpread(_MakeVanillaSwap self, Spread sp) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withFloatingLegSpread(self, sp)

    def withDiscountingTermStructure(self, discountCurve):
        r"""withDiscountingTermStructure(_MakeVanillaSwap self, YieldTermStructureHandle discountCurve) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withDiscountingTermStructure(self, discountCurve)

    def withPricingEngine(self, engine):
        r"""withPricingEngine(_MakeVanillaSwap self, ext::shared_ptr< PricingEngine > const & engine) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withPricingEngine(self, engine)

    def withIndexedCoupons(self, flag=True):
        r"""withIndexedCoupons(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withIndexedCoupons(self, flag)

    def withAtParCoupons(self, flag=True):
        r"""withAtParCoupons(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"""
        return _QuantLib._MakeVanillaSwap_withAtParCoupons(self, flag)

    def __init__(self, swapTenor, index, fixedRate, forwardStart):
        r"""__init__(_MakeVanillaSwap self, Period swapTenor, ext::shared_ptr< IborIndex > const & index, Rate fixedRate, Period forwardStart) -> _MakeVanillaSwap"""
        _QuantLib._MakeVanillaSwap_swiginit(self, _QuantLib.new__MakeVanillaSwap(swapTenor, index, fixedRate, forwardStart))

    def makeVanillaSwap(self):
        r"""makeVanillaSwap(_MakeVanillaSwap self) -> ext::shared_ptr< VanillaSwap >"""
        return _QuantLib._MakeVanillaSwap_makeVanillaSwap(self)
    __swig_destroy__ = _QuantLib.delete__MakeVanillaSwap

# Register _MakeVanillaSwap in _QuantLib:
_QuantLib._MakeVanillaSwap_swigregister(_MakeVanillaSwap)

def MakeVanillaSwap(swapTenor, iborIndex, fixedRate, forwardStart,
    receiveFixed=None, swapType=None, Nominal=None, settlementDays=None,
    effectiveDate=None, terminationDate=None, dateGenerationRule=None,
    fixedLegTenor=None, fixedLegCalendar=None, fixedLegConvention=None,
    fixedLegDayCount=None, floatingLegTenor=None, floatingLegCalendar=None,
    floatingLegConvention=None, floatingLegDayCount=None, floatingLegSpread=None,
    discountingTermStructure=None, pricingEngine=None,
    fixedLegTerminationDateConvention=None,  fixedLegDateGenRule=None,
    fixedLegEndOfMonth=None, fixedLegFirstDate=None, fixedLegNextToLastDate=None,
    floatingLegTerminationDateConvention=None, floatingLegDateGenRule=None,
    floatingLegEndOfMonth=None, floatingLegFirstDate=None, floatingLegNextToLastDate=None,
    withIndexedCoupons=None):
    mv = _MakeVanillaSwap(swapTenor, iborIndex, fixedRate, forwardStart)
    if receiveFixed is not None:
        mv.receiveFixed(receiveFixed)
    if swapType is not None:
        mv.withType(swapType)
    if Nominal is not None:
        mv.withNominal(Nominal)
    if settlementDays is not None:
        mv.withSettlementDays(settlementDays)
    if effectiveDate is not None:
        mv.withEffectiveDate(effectiveDate)
    if terminationDate is not None:
        mv.withTerminationDate(terminationDate)
    if dateGenerationRule is not None:
        mv.withRule(dateGenerationRule)
    if fixedLegTenor is not None:
        mv.withFixedLegTenor(fixedLegTenor)
    if fixedLegCalendar is not None:
        mv.withFixedLegCalendar(fixedLegCalendar)
    if fixedLegConvention is not None:
        mv.withFixedLegConvention(fixedLegConvention)
    if fixedLegDayCount is not None:
        mv.withFixedLegDayCount(fixedLegDayCount)
    if floatingLegTenor is not None:
        mv.withFloatingLegTenor(floatingLegTenor)
    if floatingLegCalendar is not None:
        mv.withFloatingLegCalendar(floatingLegCalendar)
    if floatingLegConvention is not None:
        mv.withFloatingLegConvention(floatingLegConvention)
    if floatingLegDayCount is not None:
        mv.withFloatingLegDayCount(floatingLegDayCount)
    if floatingLegSpread is not None:
        mv.withFloatingLegSpread(floatingLegSpread)
    if discountingTermStructure is not None:
        mv.withDiscountingTermStructure(discountingTermStructure)
    if pricingEngine is not None:
        mv.withPricingEngine(pricingEngine)
    if fixedLegTerminationDateConvention is not None:
        mv.withFixedLegTerminationDateConvention(fixedLegTerminationDateConvention)
    if fixedLegDateGenRule is not None:
        mv.withFixedLegRule(fixedLegDateGenRule)
    if fixedLegEndOfMonth is not None:
        mv.withFixedLegEndOfMonth(fixedLegEndOfMonth)
    if fixedLegFirstDate is not None:
        mv.withFixedLegFirstDate(fixedLegFirstDate)
    if fixedLegNextToLastDate is not None:
        mv.withFixedLegNextToLastDate(fixedLegNextToLastDate)
    if floatingLegTerminationDateConvention is not None:
        mv.withFloatingLegTerminationDateConvention(floatingLegTerminationDateConvention)
    if floatingLegDateGenRule is not None:
        mv.withFloatingLegRule(floatingLegDateGenRule)
    if floatingLegEndOfMonth is not None:
        mv.withFloatingLegEndOfMonth(floatingLegEndOfMonth)
    if floatingLegFirstDate is not None:
        mv.withFloatingLegFirstDate(floatingLegFirstDate)
    if floatingLegNextToLastDate is not None:
        mv.withFloatingLegNextToLastDate(floatingLegNextToLastDate)
    if withIndexedCoupons is not None:
        mv.withIndexedCoupons(withIndexedCoupons)
    return mv.makeVanillaSwap()

class NonstandardSwap(Swap):
    r"""Proxy of C++ NonstandardSwap class."""

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

    def __init__(self, type, fixedNominal, floatingNominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, gearing, spread, floatDayCount, intermediateCapitalExchange=False, finalCapitalExchange=False, paymentConvention=Following):
        r"""__init__(NonstandardSwap self, Swap::Type type, DoubleVector fixedNominal, DoubleVector floatingNominal, Schedule fixedSchedule, DoubleVector fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, ext::shared_ptr< IborIndex > const & index, DoubleVector gearing, DoubleVector spread, DayCounter floatDayCount, bool const intermediateCapitalExchange=False, bool const finalCapitalExchange=False, BusinessDayConvention paymentConvention=Following) -> NonstandardSwap"""
        _QuantLib.NonstandardSwap_swiginit(self, _QuantLib.new_NonstandardSwap(type, fixedNominal, floatingNominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, gearing, spread, floatDayCount, intermediateCapitalExchange, finalCapitalExchange, paymentConvention))

    def type(self):
        r"""type(NonstandardSwap self) -> Swap::Type"""
        return _QuantLib.NonstandardSwap_type(self)

    def fixedNominal(self):
        r"""fixedNominal(NonstandardSwap self) -> DoubleVector"""
        return _QuantLib.NonstandardSwap_fixedNominal(self)

    def floatingNominal(self):
        r"""floatingNominal(NonstandardSwap self) -> DoubleVector"""
        return _QuantLib.NonstandardSwap_floatingNominal(self)

    def fixedSchedule(self):
        r"""fixedSchedule(NonstandardSwap self) -> Schedule"""
        return _QuantLib.NonstandardSwap_fixedSchedule(self)

    def fixedRate(self):
        r"""fixedRate(NonstandardSwap self) -> DoubleVector"""
        return _QuantLib.NonstandardSwap_fixedRate(self)

    def fixedDayCount(self):
        r"""fixedDayCount(NonstandardSwap self) -> DayCounter"""
        return _QuantLib.NonstandardSwap_fixedDayCount(self)

    def floatingSchedule(self):
        r"""floatingSchedule(NonstandardSwap self) -> Schedule"""
        return _QuantLib.NonstandardSwap_floatingSchedule(self)

    def iborIndex(self):
        r"""iborIndex(NonstandardSwap self) -> ext::shared_ptr< IborIndex > const &"""
        return _QuantLib.NonstandardSwap_iborIndex(self)

    def spread(self):
        r"""spread(NonstandardSwap self) -> Spread"""
        return _QuantLib.NonstandardSwap_spread(self)

    def gearing(self):
        r"""gearing(NonstandardSwap self) -> Real"""
        return _QuantLib.NonstandardSwap_gearing(self)

    def spreads(self):
        r"""spreads(NonstandardSwap self) -> DoubleVector"""
        return _QuantLib.NonstandardSwap_spreads(self)

    def gearings(self):
        r"""gearings(NonstandardSwap self) -> DoubleVector"""
        return _QuantLib.NonstandardSwap_gearings(self)

    def floatingDayCount(self):
        r"""floatingDayCount(NonstandardSwap self) -> DayCounter"""
        return _QuantLib.NonstandardSwap_floatingDayCount(self)

    def paymentConvention(self):
        r"""paymentConvention(NonstandardSwap self) -> BusinessDayConvention"""
        return _QuantLib.NonstandardSwap_paymentConvention(self)

    def fixedLeg(self):
        r"""fixedLeg(NonstandardSwap self) -> Leg"""
        return _QuantLib.NonstandardSwap_fixedLeg(self)

    def floatingLeg(self):
        r"""floatingLeg(NonstandardSwap self) -> Leg"""
        return _QuantLib.NonstandardSwap_floatingLeg(self)
    __swig_destroy__ = _QuantLib.delete_NonstandardSwap

# Register NonstandardSwap in _QuantLib:
_QuantLib.NonstandardSwap_swigregister(NonstandardSwap)
class DiscountingSwapEngine(PricingEngine):
    r"""Proxy of C++ DiscountingSwapEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(DiscountingSwapEngine self, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> DiscountingSwapEngine
        __init__(DiscountingSwapEngine self, YieldTermStructureHandle discountCurve, Date settlementDate=Date(), Date npvDate=Date()) -> DiscountingSwapEngine
        """
        _QuantLib.DiscountingSwapEngine_swiginit(self, _QuantLib.new_DiscountingSwapEngine(*args))
    __swig_destroy__ = _QuantLib.delete_DiscountingSwapEngine

# Register DiscountingSwapEngine in _QuantLib:
_QuantLib.DiscountingSwapEngine_swigregister(DiscountingSwapEngine)
class AssetSwap(Swap):
    r"""Proxy of C++ AssetSwap class."""

    thisown = 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):
        r"""__init__(AssetSwap self, bool payFixedRate, ext::shared_ptr< Bond > const & bond, Real bondCleanPrice, ext::shared_ptr< IborIndex > const & index, Spread spread, Schedule floatSchedule=Schedule(), DayCounter floatingDayCount=DayCounter(), bool parAssetSwap=True) -> AssetSwap"""
        _QuantLib.AssetSwap_swiginit(self, _QuantLib.new_AssetSwap(*args, **kwargs))

    def fairCleanPrice(self):
        r"""fairCleanPrice(AssetSwap self) -> Real"""
        return _QuantLib.AssetSwap_fairCleanPrice(self)

    def fairSpread(self):
        r"""fairSpread(AssetSwap self) -> Spread"""
        return _QuantLib.AssetSwap_fairSpread(self)
    __swig_destroy__ = _QuantLib.delete_AssetSwap

# Register AssetSwap in _QuantLib:
_QuantLib.AssetSwap_swigregister(AssetSwap)
class FloatFloatSwap(Swap):
    r"""Proxy of C++ FloatFloatSwap class."""

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

    def __init__(self, *args):
        r"""__init__(FloatFloatSwap self, Swap::Type type, DoubleVector nominal1, DoubleVector nominal2, Schedule schedule1, ext::shared_ptr< InterestRateIndex > const & index1, DayCounter dayCount1, Schedule schedule2, ext::shared_ptr< InterestRateIndex > const & index2, DayCounter dayCount2, bool const intermediateCapitalExchange=False, bool const finalCapitalExchange=False, DoubleVector gearing1=std::vector< Real >(), DoubleVector spread1=std::vector< Real >(), DoubleVector cappedRate1=std::vector< Real >(), DoubleVector flooredRate1=std::vector< Real >(), DoubleVector gearing2=std::vector< Real >(), DoubleVector spread2=std::vector< Real >(), DoubleVector cappedRate2=std::vector< Real >(), DoubleVector flooredRate2=std::vector< Real >(), BusinessDayConvention paymentConvention1=Following, BusinessDayConvention paymentConvention2=Following) -> FloatFloatSwap"""
        _QuantLib.FloatFloatSwap_swiginit(self, _QuantLib.new_FloatFloatSwap(*args))
    __swig_destroy__ = _QuantLib.delete_FloatFloatSwap

# Register FloatFloatSwap in _QuantLib:
_QuantLib.FloatFloatSwap_swigregister(FloatFloatSwap)
class OvernightIndexedSwap(Swap):
    r"""Proxy of C++ OvernightIndexedSwap class."""

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

    def __init__(self, *args):
        r"""
        __init__(OvernightIndexedSwap self, Swap::Type type, Real nominal, Schedule schedule, Rate fixedRate, DayCounter fixedDC, ext::shared_ptr< OvernightIndex > const & index, Spread spread=0.0, Natural paymentLag=0, BusinessDayConvention paymentAdjustment=Following, Calendar paymentCalendar=Calendar(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound) -> OvernightIndexedSwap
        __init__(OvernightIndexedSwap self, Swap::Type type, DoubleVector nominals, Schedule schedule, Rate fixedRate, DayCounter fixedDC, ext::shared_ptr< OvernightIndex > const & index, Spread spread=0.0, Natural paymentLag=0, BusinessDayConvention paymentAdjustment=Following, Calendar paymentCalendar=Calendar(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound) -> OvernightIndexedSwap
        """
        _QuantLib.OvernightIndexedSwap_swiginit(self, _QuantLib.new_OvernightIndexedSwap(*args))

    def fixedLegBPS(self):
        r"""fixedLegBPS(OvernightIndexedSwap self) -> Rate"""
        return _QuantLib.OvernightIndexedSwap_fixedLegBPS(self)

    def fixedLegNPV(self):
        r"""fixedLegNPV(OvernightIndexedSwap self) -> Real"""
        return _QuantLib.OvernightIndexedSwap_fixedLegNPV(self)

    def fairRate(self):
        r"""fairRate(OvernightIndexedSwap self) -> Real"""
        return _QuantLib.OvernightIndexedSwap_fairRate(self)

    def overnightLegBPS(self):
        r"""overnightLegBPS(OvernightIndexedSwap self) -> Real"""
        return _QuantLib.OvernightIndexedSwap_overnightLegBPS(self)

    def overnightLegNPV(self):
        r"""overnightLegNPV(OvernightIndexedSwap self) -> Real"""
        return _QuantLib.OvernightIndexedSwap_overnightLegNPV(self)

    def fairSpread(self):
        r"""fairSpread(OvernightIndexedSwap self) -> Spread"""
        return _QuantLib.OvernightIndexedSwap_fairSpread(self)

    def type(self):
        r"""type(OvernightIndexedSwap self) -> Swap::Type"""
        return _QuantLib.OvernightIndexedSwap_type(self)

    def nominal(self):
        r"""nominal(OvernightIndexedSwap self) -> Real"""
        return _QuantLib.OvernightIndexedSwap_nominal(self)

    def nominals(self):
        r"""nominals(OvernightIndexedSwap self) -> DoubleVector"""
        return _QuantLib.OvernightIndexedSwap_nominals(self)

    def paymentFrequency(self):
        r"""paymentFrequency(OvernightIndexedSwap self) -> Frequency"""
        return _QuantLib.OvernightIndexedSwap_paymentFrequency(self)

    def fixedRate(self):
        r"""fixedRate(OvernightIndexedSwap self) -> Rate"""
        return _QuantLib.OvernightIndexedSwap_fixedRate(self)

    def fixedDayCount(self):
        r"""fixedDayCount(OvernightIndexedSwap self) -> DayCounter"""
        return _QuantLib.OvernightIndexedSwap_fixedDayCount(self)

    def spread(self):
        r"""spread(OvernightIndexedSwap self) -> Spread"""
        return _QuantLib.OvernightIndexedSwap_spread(self)

    def fixedLeg(self):
        r"""fixedLeg(OvernightIndexedSwap self) -> Leg"""
        return _QuantLib.OvernightIndexedSwap_fixedLeg(self)

    def overnightLeg(self):
        r"""overnightLeg(OvernightIndexedSwap self) -> Leg"""
        return _QuantLib.OvernightIndexedSwap_overnightLeg(self)

    def averagingMethod(self):
        r"""averagingMethod(OvernightIndexedSwap self) -> RateAveraging::Type"""
        return _QuantLib.OvernightIndexedSwap_averagingMethod(self)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexedSwap

# Register OvernightIndexedSwap in _QuantLib:
_QuantLib.OvernightIndexedSwap_swigregister(OvernightIndexedSwap)
class _MakeOIS(object):
    r"""Proxy of C++ MakeOIS class."""

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

    def __init__(self, *args):
        r"""__init__(_MakeOIS self, Period swapTenor, ext::shared_ptr< OvernightIndex > const & overnightIndex, Rate fixedRate=Null< Rate >(), Period fwdStart=0*Days) -> _MakeOIS"""
        _QuantLib._MakeOIS_swiginit(self, _QuantLib.new__MakeOIS(*args))

    def makeOIS(self):
        r"""makeOIS(_MakeOIS self) -> ext::shared_ptr< OvernightIndexedSwap >"""
        return _QuantLib._MakeOIS_makeOIS(self)

    def receiveFixed(self, flag=True):
        r"""receiveFixed(_MakeOIS self, bool flag=True) -> _MakeOIS"""
        return _QuantLib._MakeOIS_receiveFixed(self, flag)

    def withType(self, type):
        r"""withType(_MakeOIS self, Swap::Type type) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withType(self, type)

    def withNominal(self, n):
        r"""withNominal(_MakeOIS self, Real n) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withNominal(self, n)

    def withSettlementDays(self, settlementDays):
        r"""withSettlementDays(_MakeOIS self, Natural settlementDays) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withSettlementDays(self, settlementDays)

    def withEffectiveDate(self, arg2):
        r"""withEffectiveDate(_MakeOIS self, Date arg2) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withEffectiveDate(self, arg2)

    def withTerminationDate(self, arg2):
        r"""withTerminationDate(_MakeOIS self, Date arg2) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withTerminationDate(self, arg2)

    def withRule(self, r):
        r"""withRule(_MakeOIS self, DateGeneration::Rule r) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withRule(self, r)

    def withPaymentFrequency(self, f):
        r"""withPaymentFrequency(_MakeOIS self, Frequency f) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withPaymentFrequency(self, f)

    def withPaymentAdjustment(self, convention):
        r"""withPaymentAdjustment(_MakeOIS self, BusinessDayConvention convention) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withPaymentAdjustment(self, convention)

    def withPaymentLag(self, lag):
        r"""withPaymentLag(_MakeOIS self, Natural lag) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withPaymentLag(self, lag)

    def withPaymentCalendar(self, cal):
        r"""withPaymentCalendar(_MakeOIS self, Calendar cal) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withPaymentCalendar(self, cal)

    def withEndOfMonth(self, flag=True):
        r"""withEndOfMonth(_MakeOIS self, bool flag=True) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withEndOfMonth(self, flag)

    def withFixedLegDayCount(self, dc):
        r"""withFixedLegDayCount(_MakeOIS self, DayCounter dc) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withFixedLegDayCount(self, dc)

    def withOvernightLegSpread(self, sp):
        r"""withOvernightLegSpread(_MakeOIS self, Spread sp) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withOvernightLegSpread(self, sp)

    def withDiscountingTermStructure(self, discountingTermStructure):
        r"""withDiscountingTermStructure(_MakeOIS self, YieldTermStructureHandle discountingTermStructure) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withDiscountingTermStructure(self, discountingTermStructure)

    def withTelescopicValueDates(self, telescopicValueDates):
        r"""withTelescopicValueDates(_MakeOIS self, bool telescopicValueDates) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withTelescopicValueDates(self, telescopicValueDates)

    def withAveragingMethod(self, averagingMethod):
        r"""withAveragingMethod(_MakeOIS self, RateAveraging::Type averagingMethod) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withAveragingMethod(self, averagingMethod)

    def withPricingEngine(self, engine):
        r"""withPricingEngine(_MakeOIS self, ext::shared_ptr< PricingEngine > const & engine) -> _MakeOIS"""
        return _QuantLib._MakeOIS_withPricingEngine(self, engine)
    __swig_destroy__ = _QuantLib.delete__MakeOIS

# Register _MakeOIS in _QuantLib:
_QuantLib._MakeOIS_swigregister(_MakeOIS)

def MakeOIS(swapTenor, overnightIndex, fixedRate, fwdStart=Period(0, Days),
            receiveFixed=True,
            swapType=Swap.Payer,
            nominal=1.0,
            settlementDays=2,
            effectiveDate=None,
            terminationDate=None,
            dateGenerationRule=DateGeneration.Backward,
            paymentFrequency=Annual,
            paymentAdjustmentConvention=Following,
            paymentLag=0,
            paymentCalendar=None,
            endOfMonth=True,    
            fixedLegDayCount=None,
            overnightLegSpread=0.0,
            discountingTermStructure=None,
            telescopicValueDates=False,
            pricingEngine=None,
            averagingMethod=None):

    mv = _MakeOIS(swapTenor, overnightIndex, fixedRate, fwdStart)

    if not receiveFixed:
        mv.receiveFixed(receiveFixed)
    if swapType != Swap.Payer:
        mv.withType(swapType)
    if nominal != 1.0:
        mv.withNominal(nominal)
    if settlementDays != 2:
        mv.withSettlementDays(settlementDays)
    if effectiveDate is not None:
        mv.withEffectiveDate(effectiveDate)
    if terminationDate is not None:
        mv.withTerminationDate(terminationDate)
    if dateGenerationRule != DateGeneration.Backward:
        mv.withRule(dateGenerationRule)  
    if paymentFrequency != Annual:
        mv.withPaymentFrequency(paymentFrequency)
    if paymentAdjustmentConvention != Following:
        mv.withPaymentAdjustment(paymentAdjustmentConvention)
    if paymentLag != 0:
        mv.withPaymentLag(paymentLag)
    if paymentCalendar is not None:
        mv.withPaymentCalendar(paymentCalendar)
    if not endOfMonth:
        mv.withEndOfMonth(endOfMonth)
    if fixedLegDayCount is not None:
        mv.withFixedLegDayCount(fixedLegDayCount)
    else:
        mv.withFixedLegDayCount(overnightIndex.dayCounter())
    if overnightLegSpread != 0.0:
        mv.withOvernightLegSpread(overnightLegSpread)
    if discountingTermStructure is not None:
        mv.withDiscountingTermStructure(discountingTermStructure)        
    if telescopicValueDates:
        mv.withTelescopicValueDates(telescopicValueDates)
    if averagingMethod is not None:
        mv.withAveragingMethod(averagingMethod)
    if pricingEngine is not None:
        mv.withPricingEngine(pricingEngine)

    return mv.makeOIS()

class OvernightIndexedSwapIndex(SwapIndex):
    r"""Proxy of C++ OvernightIndexedSwapIndex class."""

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

    def __init__(self, *args):
        r"""__init__(OvernightIndexedSwapIndex self, std::string const & familyName, Period tenor, Natural settlementDays, Currency currency, ext::shared_ptr< OvernightIndex > const & overnightIndex, bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound) -> OvernightIndexedSwapIndex"""
        _QuantLib.OvernightIndexedSwapIndex_swiginit(self, _QuantLib.new_OvernightIndexedSwapIndex(*args))

    def overnightIndex(self):
        r"""overnightIndex(OvernightIndexedSwapIndex self) -> ext::shared_ptr< OvernightIndex >"""
        return _QuantLib.OvernightIndexedSwapIndex_overnightIndex(self)

    def underlyingSwap(self, fixingDate):
        r"""underlyingSwap(OvernightIndexedSwapIndex self, Date fixingDate) -> ext::shared_ptr< OvernightIndexedSwap >"""
        return _QuantLib.OvernightIndexedSwapIndex_underlyingSwap(self, fixingDate)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexedSwapIndex

# Register OvernightIndexedSwapIndex in _QuantLib:
_QuantLib.OvernightIndexedSwapIndex_swigregister(OvernightIndexedSwapIndex)

def as_overnight_swap_index(index):
    r"""as_overnight_swap_index(ext::shared_ptr< InterestRateIndex > const & index) -> ext::shared_ptr< OvernightIndexedSwap >"""
    return _QuantLib.as_overnight_swap_index(index)
class ZeroCouponSwap(Swap):
    r"""Proxy of C++ ZeroCouponSwap class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZeroCouponSwap self, Swap::Type type, Real baseNominal, Date startDate, Date maturityDate, Real fixedPayment, ext::shared_ptr< IborIndex > iborIndex, Calendar paymentCalendar, BusinessDayConvention paymentConvention=Following, Natural paymentDelay=0) -> ZeroCouponSwap
        __init__(ZeroCouponSwap self, Swap::Type type, Real baseNominal, Date startDate, Date maturityDate, Rate fixedRate, DayCounter fixedDayCounter, ext::shared_ptr< IborIndex > iborIndex, Calendar paymentCalendar, BusinessDayConvention paymentConvention=Following, Natural paymentDelay=0) -> ZeroCouponSwap
        """
        _QuantLib.ZeroCouponSwap_swiginit(self, _QuantLib.new_ZeroCouponSwap(*args))

    def type(self):
        r"""type(ZeroCouponSwap self) -> Swap::Type"""
        return _QuantLib.ZeroCouponSwap_type(self)

    def baseNominal(self):
        r"""baseNominal(ZeroCouponSwap self) -> Real"""
        return _QuantLib.ZeroCouponSwap_baseNominal(self)

    def iborIndex(self):
        r"""iborIndex(ZeroCouponSwap self) -> ext::shared_ptr< IborIndex > const &"""
        return _QuantLib.ZeroCouponSwap_iborIndex(self)

    def fixedLeg(self):
        r"""fixedLeg(ZeroCouponSwap self) -> Leg"""
        return _QuantLib.ZeroCouponSwap_fixedLeg(self)

    def floatingLeg(self):
        r"""floatingLeg(ZeroCouponSwap self) -> Leg"""
        return _QuantLib.ZeroCouponSwap_floatingLeg(self)

    def fixedPayment(self):
        r"""fixedPayment(ZeroCouponSwap self) -> Real"""
        return _QuantLib.ZeroCouponSwap_fixedPayment(self)

    def fixedLegNPV(self):
        r"""fixedLegNPV(ZeroCouponSwap self) -> Real"""
        return _QuantLib.ZeroCouponSwap_fixedLegNPV(self)

    def floatingLegNPV(self):
        r"""floatingLegNPV(ZeroCouponSwap self) -> Real"""
        return _QuantLib.ZeroCouponSwap_floatingLegNPV(self)

    def fairFixedPayment(self):
        r"""fairFixedPayment(ZeroCouponSwap self) -> Real"""
        return _QuantLib.ZeroCouponSwap_fairFixedPayment(self)

    def fairFixedRate(self, dayCounter):
        r"""fairFixedRate(ZeroCouponSwap self, DayCounter dayCounter) -> Rate"""
        return _QuantLib.ZeroCouponSwap_fairFixedRate(self, dayCounter)
    __swig_destroy__ = _QuantLib.delete_ZeroCouponSwap

# Register ZeroCouponSwap in _QuantLib:
_QuantLib.ZeroCouponSwap_swigregister(ZeroCouponSwap)
class Seasonality(object):
    r"""Proxy of C++ Seasonality class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def correctZeroRate(self, d, r, iTS):
        r"""correctZeroRate(Seasonality self, Date d, Rate const r, InflationTermStructure iTS) -> Rate"""
        return _QuantLib.Seasonality_correctZeroRate(self, d, r, iTS)

    def correctYoYRate(self, d, r, iTS):
        r"""correctYoYRate(Seasonality self, Date d, Rate const r, InflationTermStructure iTS) -> Rate"""
        return _QuantLib.Seasonality_correctYoYRate(self, d, r, iTS)

    def isConsistent(self, iTS):
        r"""isConsistent(Seasonality self, InflationTermStructure iTS) -> bool"""
        return _QuantLib.Seasonality_isConsistent(self, iTS)
    __swig_destroy__ = _QuantLib.delete_Seasonality

# Register Seasonality in _QuantLib:
_QuantLib.Seasonality_swigregister(Seasonality)
class MultiplicativePriceSeasonality(Seasonality):
    r"""Proxy of C++ MultiplicativePriceSeasonality class."""

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

    def __init__(self, seasonalityBaseDate, frequency, seasonalityFactors):
        r"""__init__(MultiplicativePriceSeasonality self, Date seasonalityBaseDate, Frequency frequency, DoubleVector seasonalityFactors) -> MultiplicativePriceSeasonality"""
        _QuantLib.MultiplicativePriceSeasonality_swiginit(self, _QuantLib.new_MultiplicativePriceSeasonality(seasonalityBaseDate, frequency, seasonalityFactors))
    __swig_destroy__ = _QuantLib.delete_MultiplicativePriceSeasonality

# Register MultiplicativePriceSeasonality in _QuantLib:
_QuantLib.MultiplicativePriceSeasonality_swigregister(MultiplicativePriceSeasonality)
class KerkhofSeasonality(Seasonality):
    r"""Proxy of C++ KerkhofSeasonality class."""

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

    def __init__(self, seasonalityBaseDate, seasonalityFactors):
        r"""__init__(KerkhofSeasonality self, Date seasonalityBaseDate, DoubleVector seasonalityFactors) -> KerkhofSeasonality"""
        _QuantLib.KerkhofSeasonality_swiginit(self, _QuantLib.new_KerkhofSeasonality(seasonalityBaseDate, seasonalityFactors))
    __swig_destroy__ = _QuantLib.delete_KerkhofSeasonality

# Register KerkhofSeasonality in _QuantLib:
_QuantLib.KerkhofSeasonality_swigregister(KerkhofSeasonality)
class InflationTermStructure(TermStructure):
    r"""Proxy of C++ InflationTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def observationLag(self):
        r"""observationLag(InflationTermStructure self) -> Period"""
        return _QuantLib.InflationTermStructure_observationLag(self)

    def frequency(self):
        r"""frequency(InflationTermStructure self) -> Frequency"""
        return _QuantLib.InflationTermStructure_frequency(self)

    def indexIsInterpolated(self):
        r"""indexIsInterpolated(InflationTermStructure self) -> bool"""
        return _QuantLib.InflationTermStructure_indexIsInterpolated(self)

    def baseRate(self):
        r"""baseRate(InflationTermStructure self) -> Rate"""
        return _QuantLib.InflationTermStructure_baseRate(self)

    def baseDate(self):
        r"""baseDate(InflationTermStructure self) -> Date"""
        return _QuantLib.InflationTermStructure_baseDate(self)

    def setSeasonality(self, *args):
        r"""setSeasonality(InflationTermStructure self, ext::shared_ptr< Seasonality > const & seasonality=ext::shared_ptr< Seasonality >())"""
        return _QuantLib.InflationTermStructure_setSeasonality(self, *args)

    def seasonality(self):
        r"""seasonality(InflationTermStructure self) -> ext::shared_ptr< Seasonality >"""
        return _QuantLib.InflationTermStructure_seasonality(self)

    def hasSeasonality(self):
        r"""hasSeasonality(InflationTermStructure self) -> bool"""
        return _QuantLib.InflationTermStructure_hasSeasonality(self)
    __swig_destroy__ = _QuantLib.delete_InflationTermStructure

# Register InflationTermStructure in _QuantLib:
_QuantLib.InflationTermStructure_swigregister(InflationTermStructure)
class YoYInflationTermStructure(InflationTermStructure):
    r"""Proxy of C++ YoYInflationTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def yoyRate(self, *args):
        r"""
        yoyRate(YoYInflationTermStructure self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate
        yoyRate(YoYInflationTermStructure self, Time t, bool extrapolate=False) -> Rate
        """
        return _QuantLib.YoYInflationTermStructure_yoyRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_YoYInflationTermStructure

# Register YoYInflationTermStructure in _QuantLib:
_QuantLib.YoYInflationTermStructure_swigregister(YoYInflationTermStructure)
class YoYInflationTermStructureHandle(object):
    r"""Proxy of C++ Handle< YoYInflationTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(YoYInflationTermStructureHandle self, ext::shared_ptr< YoYInflationTermStructure > const & arg2=ext::shared_ptr()) -> YoYInflationTermStructureHandle"""
        _QuantLib.YoYInflationTermStructureHandle_swiginit(self, _QuantLib.new_YoYInflationTermStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(YoYInflationTermStructureHandle self) -> ext::shared_ptr< YoYInflationTermStructure >"""
        return _QuantLib.YoYInflationTermStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(YoYInflationTermStructureHandle self) -> ext::shared_ptr< YoYInflationTermStructure >"""
        return _QuantLib.YoYInflationTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(YoYInflationTermStructureHandle self) -> bool"""
        return _QuantLib.YoYInflationTermStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(YoYInflationTermStructureHandle self) -> bool"""
        return _QuantLib.YoYInflationTermStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(YoYInflationTermStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.YoYInflationTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationTermStructureHandle

    def yoyRate(self, *args):
        r"""
        yoyRate(YoYInflationTermStructureHandle self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate
        yoyRate(YoYInflationTermStructureHandle self, Time t, bool extrapolate=False) -> Rate
        """
        return _QuantLib.YoYInflationTermStructureHandle_yoyRate(self, *args)

    def observationLag(self):
        r"""observationLag(YoYInflationTermStructureHandle self) -> Period"""
        return _QuantLib.YoYInflationTermStructureHandle_observationLag(self)

    def frequency(self):
        r"""frequency(YoYInflationTermStructureHandle self) -> Frequency"""
        return _QuantLib.YoYInflationTermStructureHandle_frequency(self)

    def indexIsInterpolated(self):
        r"""indexIsInterpolated(YoYInflationTermStructureHandle self) -> bool"""
        return _QuantLib.YoYInflationTermStructureHandle_indexIsInterpolated(self)

    def baseRate(self):
        r"""baseRate(YoYInflationTermStructureHandle self) -> Rate"""
        return _QuantLib.YoYInflationTermStructureHandle_baseRate(self)

    def baseDate(self):
        r"""baseDate(YoYInflationTermStructureHandle self) -> Date"""
        return _QuantLib.YoYInflationTermStructureHandle_baseDate(self)

    def setSeasonality(self, *args):
        r"""setSeasonality(YoYInflationTermStructureHandle self, ext::shared_ptr< Seasonality > const & seasonality=ext::shared_ptr< Seasonality >())"""
        return _QuantLib.YoYInflationTermStructureHandle_setSeasonality(self, *args)

    def seasonality(self):
        r"""seasonality(YoYInflationTermStructureHandle self) -> ext::shared_ptr< Seasonality >"""
        return _QuantLib.YoYInflationTermStructureHandle_seasonality(self)

    def hasSeasonality(self):
        r"""hasSeasonality(YoYInflationTermStructureHandle self) -> bool"""
        return _QuantLib.YoYInflationTermStructureHandle_hasSeasonality(self)

    def dayCounter(self):
        r"""dayCounter(YoYInflationTermStructureHandle self) -> DayCounter"""
        return _QuantLib.YoYInflationTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(YoYInflationTermStructureHandle self, Date date) -> Time"""
        return _QuantLib.YoYInflationTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(YoYInflationTermStructureHandle self) -> Calendar"""
        return _QuantLib.YoYInflationTermStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(YoYInflationTermStructureHandle self) -> Date"""
        return _QuantLib.YoYInflationTermStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(YoYInflationTermStructureHandle self) -> Date"""
        return _QuantLib.YoYInflationTermStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(YoYInflationTermStructureHandle self) -> Time"""
        return _QuantLib.YoYInflationTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(YoYInflationTermStructureHandle self)"""
        return _QuantLib.YoYInflationTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(YoYInflationTermStructureHandle self)"""
        return _QuantLib.YoYInflationTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(YoYInflationTermStructureHandle self) -> bool"""
        return _QuantLib.YoYInflationTermStructureHandle_allowsExtrapolation(self)

# Register YoYInflationTermStructureHandle in _QuantLib:
_QuantLib.YoYInflationTermStructureHandle_swigregister(YoYInflationTermStructureHandle)
class RelinkableYoYInflationTermStructureHandle(YoYInflationTermStructureHandle):
    r"""Proxy of C++ RelinkableHandle< YoYInflationTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableYoYInflationTermStructureHandle self, ext::shared_ptr< YoYInflationTermStructure > const & arg2=ext::shared_ptr()) -> RelinkableYoYInflationTermStructureHandle"""
        _QuantLib.RelinkableYoYInflationTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableYoYInflationTermStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableYoYInflationTermStructureHandle self, ext::shared_ptr< YoYInflationTermStructure > const & arg2)"""
        return _QuantLib.RelinkableYoYInflationTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableYoYInflationTermStructureHandle self)"""
        return _QuantLib.RelinkableYoYInflationTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableYoYInflationTermStructureHandle

# Register RelinkableYoYInflationTermStructureHandle in _QuantLib:
_QuantLib.RelinkableYoYInflationTermStructureHandle_swigregister(RelinkableYoYInflationTermStructureHandle)
class ZeroInflationTermStructure(InflationTermStructure):
    r"""Proxy of C++ ZeroInflationTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def zeroRate(self, *args):
        r"""
        zeroRate(ZeroInflationTermStructure self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate
        zeroRate(ZeroInflationTermStructure self, Time t, bool extrapolate=False) -> Rate
        """
        return _QuantLib.ZeroInflationTermStructure_zeroRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationTermStructure

# Register ZeroInflationTermStructure in _QuantLib:
_QuantLib.ZeroInflationTermStructure_swigregister(ZeroInflationTermStructure)
class ZeroInflationTermStructureHandle(object):
    r"""Proxy of C++ Handle< ZeroInflationTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(ZeroInflationTermStructureHandle self, ext::shared_ptr< ZeroInflationTermStructure > const & arg2=ext::shared_ptr()) -> ZeroInflationTermStructureHandle"""
        _QuantLib.ZeroInflationTermStructureHandle_swiginit(self, _QuantLib.new_ZeroInflationTermStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< ZeroInflationTermStructure >"""
        return _QuantLib.ZeroInflationTermStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< ZeroInflationTermStructure >"""
        return _QuantLib.ZeroInflationTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(ZeroInflationTermStructureHandle self) -> bool"""
        return _QuantLib.ZeroInflationTermStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ZeroInflationTermStructureHandle self) -> bool"""
        return _QuantLib.ZeroInflationTermStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.ZeroInflationTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationTermStructureHandle

    def zeroRate(self, *args):
        r"""
        zeroRate(ZeroInflationTermStructureHandle self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate
        zeroRate(ZeroInflationTermStructureHandle self, Time t, bool extrapolate=False) -> Rate
        """
        return _QuantLib.ZeroInflationTermStructureHandle_zeroRate(self, *args)

    def observationLag(self):
        r"""observationLag(ZeroInflationTermStructureHandle self) -> Period"""
        return _QuantLib.ZeroInflationTermStructureHandle_observationLag(self)

    def frequency(self):
        r"""frequency(ZeroInflationTermStructureHandle self) -> Frequency"""
        return _QuantLib.ZeroInflationTermStructureHandle_frequency(self)

    def indexIsInterpolated(self):
        r"""indexIsInterpolated(ZeroInflationTermStructureHandle self) -> bool"""
        return _QuantLib.ZeroInflationTermStructureHandle_indexIsInterpolated(self)

    def baseRate(self):
        r"""baseRate(ZeroInflationTermStructureHandle self) -> Rate"""
        return _QuantLib.ZeroInflationTermStructureHandle_baseRate(self)

    def baseDate(self):
        r"""baseDate(ZeroInflationTermStructureHandle self) -> Date"""
        return _QuantLib.ZeroInflationTermStructureHandle_baseDate(self)

    def setSeasonality(self, *args):
        r"""setSeasonality(ZeroInflationTermStructureHandle self, ext::shared_ptr< Seasonality > const & seasonality=ext::shared_ptr< Seasonality >())"""
        return _QuantLib.ZeroInflationTermStructureHandle_setSeasonality(self, *args)

    def seasonality(self):
        r"""seasonality(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< Seasonality >"""
        return _QuantLib.ZeroInflationTermStructureHandle_seasonality(self)

    def hasSeasonality(self):
        r"""hasSeasonality(ZeroInflationTermStructureHandle self) -> bool"""
        return _QuantLib.ZeroInflationTermStructureHandle_hasSeasonality(self)

    def dayCounter(self):
        r"""dayCounter(ZeroInflationTermStructureHandle self) -> DayCounter"""
        return _QuantLib.ZeroInflationTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(ZeroInflationTermStructureHandle self, Date date) -> Time"""
        return _QuantLib.ZeroInflationTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(ZeroInflationTermStructureHandle self) -> Calendar"""
        return _QuantLib.ZeroInflationTermStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(ZeroInflationTermStructureHandle self) -> Date"""
        return _QuantLib.ZeroInflationTermStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(ZeroInflationTermStructureHandle self) -> Date"""
        return _QuantLib.ZeroInflationTermStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(ZeroInflationTermStructureHandle self) -> Time"""
        return _QuantLib.ZeroInflationTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(ZeroInflationTermStructureHandle self)"""
        return _QuantLib.ZeroInflationTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(ZeroInflationTermStructureHandle self)"""
        return _QuantLib.ZeroInflationTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(ZeroInflationTermStructureHandle self) -> bool"""
        return _QuantLib.ZeroInflationTermStructureHandle_allowsExtrapolation(self)

# Register ZeroInflationTermStructureHandle in _QuantLib:
_QuantLib.ZeroInflationTermStructureHandle_swigregister(ZeroInflationTermStructureHandle)
class RelinkableZeroInflationTermStructureHandle(ZeroInflationTermStructureHandle):
    r"""Proxy of C++ RelinkableHandle< ZeroInflationTermStructure > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableZeroInflationTermStructureHandle self, ext::shared_ptr< ZeroInflationTermStructure > const & arg2=ext::shared_ptr()) -> RelinkableZeroInflationTermStructureHandle"""
        _QuantLib.RelinkableZeroInflationTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableZeroInflationTermStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableZeroInflationTermStructureHandle self, ext::shared_ptr< ZeroInflationTermStructure > const & arg2)"""
        return _QuantLib.RelinkableZeroInflationTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableZeroInflationTermStructureHandle self)"""
        return _QuantLib.RelinkableZeroInflationTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableZeroInflationTermStructureHandle

# Register RelinkableZeroInflationTermStructureHandle in _QuantLib:
_QuantLib.RelinkableZeroInflationTermStructureHandle_swigregister(RelinkableZeroInflationTermStructureHandle)
class Region(object):
    r"""Proxy of C++ Region class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def name(self):
        r"""name(Region self) -> std::string"""
        return _QuantLib.Region_name(self)

    def code(self):
        r"""code(Region self) -> std::string"""
        return _QuantLib.Region_code(self)
    __swig_destroy__ = _QuantLib.delete_Region

# Register Region in _QuantLib:
_QuantLib.Region_swigregister(Region)
class CustomRegion(Region):
    r"""Proxy of C++ CustomRegion class."""

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

    def __init__(self, name, code):
        r"""__init__(CustomRegion self, std::string const & name, std::string const & code) -> CustomRegion"""
        _QuantLib.CustomRegion_swiginit(self, _QuantLib.new_CustomRegion(name, code))
    __swig_destroy__ = _QuantLib.delete_CustomRegion

# Register CustomRegion in _QuantLib:
_QuantLib.CustomRegion_swigregister(CustomRegion)
class InflationIndex(Index):
    r"""Proxy of C++ InflationIndex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def familyName(self):
        r"""familyName(InflationIndex self) -> std::string"""
        return _QuantLib.InflationIndex_familyName(self)

    def region(self):
        r"""region(InflationIndex self) -> Region"""
        return _QuantLib.InflationIndex_region(self)

    def revised(self):
        r"""revised(InflationIndex self) -> bool"""
        return _QuantLib.InflationIndex_revised(self)

    def interpolated(self):
        r"""interpolated(InflationIndex self) -> bool"""
        return _QuantLib.InflationIndex_interpolated(self)

    def frequency(self):
        r"""frequency(InflationIndex self) -> Frequency"""
        return _QuantLib.InflationIndex_frequency(self)

    def availabilityLag(self):
        r"""availabilityLag(InflationIndex self) -> Period"""
        return _QuantLib.InflationIndex_availabilityLag(self)

    def currency(self):
        r"""currency(InflationIndex self) -> Currency"""
        return _QuantLib.InflationIndex_currency(self)
    __swig_destroy__ = _QuantLib.delete_InflationIndex

# Register InflationIndex in _QuantLib:
_QuantLib.InflationIndex_swigregister(InflationIndex)
class ZeroInflationIndex(InflationIndex):
    r"""Proxy of C++ ZeroInflationIndex class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZeroInflationIndex self, std::string const & familyName, Region region, bool revised, Frequency frequency, Period availabilityLag, Currency currency, ZeroInflationTermStructureHandle h={}) -> ZeroInflationIndex
        __init__(ZeroInflationIndex self, std::string const & familyName, Region region, bool revised, bool interpolated, Frequency frequency, Period availabilityLag, Currency currency, ZeroInflationTermStructureHandle h={}) -> ZeroInflationIndex
        """
        _QuantLib.ZeroInflationIndex_swiginit(self, _QuantLib.new_ZeroInflationIndex(*args))

    def zeroInflationTermStructure(self):
        r"""zeroInflationTermStructure(ZeroInflationIndex self) -> ZeroInflationTermStructureHandle"""
        return _QuantLib.ZeroInflationIndex_zeroInflationTermStructure(self)

    def clone(self, h):
        r"""clone(ZeroInflationIndex self, ZeroInflationTermStructureHandle h) -> ext::shared_ptr< ZeroInflationIndex >"""
        return _QuantLib.ZeroInflationIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationIndex

# Register ZeroInflationIndex in _QuantLib:
_QuantLib.ZeroInflationIndex_swigregister(ZeroInflationIndex)

def as_zero_inflation_index(i):
    r"""as_zero_inflation_index(ext::shared_ptr< Index > const & i) -> ext::shared_ptr< ZeroInflationIndex >"""
    return _QuantLib.as_zero_inflation_index(i)
class YoYInflationIndex(InflationIndex):
    r"""Proxy of C++ YoYInflationIndex class."""

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

    def __init__(self, *args):
        r"""__init__(YoYInflationIndex self, std::string const & familyName, Region region, bool revised, bool interpolated, bool ratio, Frequency frequency, Period availabilityLag, Currency currency, YoYInflationTermStructureHandle ts={}) -> YoYInflationIndex"""
        _QuantLib.YoYInflationIndex_swiginit(self, _QuantLib.new_YoYInflationIndex(*args))

    def ratio(self):
        r"""ratio(YoYInflationIndex self) -> bool"""
        return _QuantLib.YoYInflationIndex_ratio(self)

    def yoyInflationTermStructure(self):
        r"""yoyInflationTermStructure(YoYInflationIndex self) -> YoYInflationTermStructureHandle"""
        return _QuantLib.YoYInflationIndex_yoyInflationTermStructure(self)

    def clone(self, h):
        r"""clone(YoYInflationIndex self, YoYInflationTermStructureHandle h) -> ext::shared_ptr< YoYInflationIndex >"""
        return _QuantLib.YoYInflationIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_YoYInflationIndex

# Register YoYInflationIndex in _QuantLib:
_QuantLib.YoYInflationIndex_swigregister(YoYInflationIndex)
class EUHICP(ZeroInflationIndex):
    r"""Proxy of C++ EUHICP class."""

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

    def __init__(self, *args):
        r"""
        __init__(EUHICP self, ZeroInflationTermStructureHandle h={}) -> EUHICP
        __init__(EUHICP self, bool interpolated, ZeroInflationTermStructureHandle h={}) -> EUHICP
        """
        _QuantLib.EUHICP_swiginit(self, _QuantLib.new_EUHICP(*args))
    __swig_destroy__ = _QuantLib.delete_EUHICP

# Register EUHICP in _QuantLib:
_QuantLib.EUHICP_swigregister(EUHICP)
class EUHICPXT(ZeroInflationIndex):
    r"""Proxy of C++ EUHICPXT class."""

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

    def __init__(self, *args):
        r"""
        __init__(EUHICPXT self, ZeroInflationTermStructureHandle h={}) -> EUHICPXT
        __init__(EUHICPXT self, bool interpolated, ZeroInflationTermStructureHandle h={}) -> EUHICPXT
        """
        _QuantLib.EUHICPXT_swiginit(self, _QuantLib.new_EUHICPXT(*args))
    __swig_destroy__ = _QuantLib.delete_EUHICPXT

# Register EUHICPXT in _QuantLib:
_QuantLib.EUHICPXT_swigregister(EUHICPXT)
class FRHICP(ZeroInflationIndex):
    r"""Proxy of C++ FRHICP class."""

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

    def __init__(self, *args):
        r"""
        __init__(FRHICP self, ZeroInflationTermStructureHandle h={}) -> FRHICP
        __init__(FRHICP self, bool interpolated, ZeroInflationTermStructureHandle h={}) -> FRHICP
        """
        _QuantLib.FRHICP_swiginit(self, _QuantLib.new_FRHICP(*args))
    __swig_destroy__ = _QuantLib.delete_FRHICP

# Register FRHICP in _QuantLib:
_QuantLib.FRHICP_swigregister(FRHICP)
class UKRPI(ZeroInflationIndex):
    r"""Proxy of C++ UKRPI class."""

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

    def __init__(self, *args):
        r"""
        __init__(UKRPI self, ZeroInflationTermStructureHandle h={}) -> UKRPI
        __init__(UKRPI self, bool interpolated, ZeroInflationTermStructureHandle h={}) -> UKRPI
        """
        _QuantLib.UKRPI_swiginit(self, _QuantLib.new_UKRPI(*args))
    __swig_destroy__ = _QuantLib.delete_UKRPI

# Register UKRPI in _QuantLib:
_QuantLib.UKRPI_swigregister(UKRPI)
class USCPI(ZeroInflationIndex):
    r"""Proxy of C++ USCPI class."""

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

    def __init__(self, *args):
        r"""
        __init__(USCPI self, ZeroInflationTermStructureHandle h={}) -> USCPI
        __init__(USCPI self, bool interpolated, ZeroInflationTermStructureHandle h={}) -> USCPI
        """
        _QuantLib.USCPI_swiginit(self, _QuantLib.new_USCPI(*args))
    __swig_destroy__ = _QuantLib.delete_USCPI

# Register USCPI in _QuantLib:
_QuantLib.USCPI_swigregister(USCPI)
class ZACPI(ZeroInflationIndex):
    r"""Proxy of C++ ZACPI class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZACPI self, ZeroInflationTermStructureHandle h={}) -> ZACPI
        __init__(ZACPI self, bool interpolated, ZeroInflationTermStructureHandle h={}) -> ZACPI
        """
        _QuantLib.ZACPI_swiginit(self, _QuantLib.new_ZACPI(*args))
    __swig_destroy__ = _QuantLib.delete_ZACPI

# Register ZACPI in _QuantLib:
_QuantLib.ZACPI_swigregister(ZACPI)
class YYEUHICP(YoYInflationIndex):
    r"""Proxy of C++ YYEUHICP class."""

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

    def __init__(self, *args):
        r"""__init__(YYEUHICP self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYEUHICP"""
        _QuantLib.YYEUHICP_swiginit(self, _QuantLib.new_YYEUHICP(*args))
    __swig_destroy__ = _QuantLib.delete_YYEUHICP

# Register YYEUHICP in _QuantLib:
_QuantLib.YYEUHICP_swigregister(YYEUHICP)
class YYEUHICPXT(YoYInflationIndex):
    r"""Proxy of C++ YYEUHICPXT class."""

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

    def __init__(self, *args):
        r"""__init__(YYEUHICPXT self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYEUHICPXT"""
        _QuantLib.YYEUHICPXT_swiginit(self, _QuantLib.new_YYEUHICPXT(*args))
    __swig_destroy__ = _QuantLib.delete_YYEUHICPXT

# Register YYEUHICPXT in _QuantLib:
_QuantLib.YYEUHICPXT_swigregister(YYEUHICPXT)
class YYEUHICPr(YoYInflationIndex):
    r"""Proxy of C++ YYEUHICPr class."""

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

    def __init__(self, *args):
        r"""__init__(YYEUHICPr self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYEUHICPr"""
        _QuantLib.YYEUHICPr_swiginit(self, _QuantLib.new_YYEUHICPr(*args))
    __swig_destroy__ = _QuantLib.delete_YYEUHICPr

# Register YYEUHICPr in _QuantLib:
_QuantLib.YYEUHICPr_swigregister(YYEUHICPr)
class YYFRHICP(YoYInflationIndex):
    r"""Proxy of C++ YYFRHICP class."""

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

    def __init__(self, *args):
        r"""__init__(YYFRHICP self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYFRHICP"""
        _QuantLib.YYFRHICP_swiginit(self, _QuantLib.new_YYFRHICP(*args))
    __swig_destroy__ = _QuantLib.delete_YYFRHICP

# Register YYFRHICP in _QuantLib:
_QuantLib.YYFRHICP_swigregister(YYFRHICP)
class YYFRHICPr(YoYInflationIndex):
    r"""Proxy of C++ YYFRHICPr class."""

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

    def __init__(self, *args):
        r"""__init__(YYFRHICPr self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYFRHICPr"""
        _QuantLib.YYFRHICPr_swiginit(self, _QuantLib.new_YYFRHICPr(*args))
    __swig_destroy__ = _QuantLib.delete_YYFRHICPr

# Register YYFRHICPr in _QuantLib:
_QuantLib.YYFRHICPr_swigregister(YYFRHICPr)
class YYUKRPI(YoYInflationIndex):
    r"""Proxy of C++ YYUKRPI class."""

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

    def __init__(self, *args):
        r"""__init__(YYUKRPI self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYUKRPI"""
        _QuantLib.YYUKRPI_swiginit(self, _QuantLib.new_YYUKRPI(*args))
    __swig_destroy__ = _QuantLib.delete_YYUKRPI

# Register YYUKRPI in _QuantLib:
_QuantLib.YYUKRPI_swigregister(YYUKRPI)
class YYUKRPIr(YoYInflationIndex):
    r"""Proxy of C++ YYUKRPIr class."""

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

    def __init__(self, *args):
        r"""__init__(YYUKRPIr self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYUKRPIr"""
        _QuantLib.YYUKRPIr_swiginit(self, _QuantLib.new_YYUKRPIr(*args))
    __swig_destroy__ = _QuantLib.delete_YYUKRPIr

# Register YYUKRPIr in _QuantLib:
_QuantLib.YYUKRPIr_swigregister(YYUKRPIr)
class YYUSCPI(YoYInflationIndex):
    r"""Proxy of C++ YYUSCPI class."""

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

    def __init__(self, *args):
        r"""__init__(YYUSCPI self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYUSCPI"""
        _QuantLib.YYUSCPI_swiginit(self, _QuantLib.new_YYUSCPI(*args))
    __swig_destroy__ = _QuantLib.delete_YYUSCPI

# Register YYUSCPI in _QuantLib:
_QuantLib.YYUSCPI_swigregister(YYUSCPI)
class YYUSCPIr(YoYInflationIndex):
    r"""Proxy of C++ YYUSCPIr class."""

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

    def __init__(self, *args):
        r"""__init__(YYUSCPIr self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYUSCPIr"""
        _QuantLib.YYUSCPIr_swiginit(self, _QuantLib.new_YYUSCPIr(*args))
    __swig_destroy__ = _QuantLib.delete_YYUSCPIr

# Register YYUSCPIr in _QuantLib:
_QuantLib.YYUSCPIr_swigregister(YYUSCPIr)
class YYZACPI(YoYInflationIndex):
    r"""Proxy of C++ YYZACPI class."""

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

    def __init__(self, *args):
        r"""__init__(YYZACPI self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYZACPI"""
        _QuantLib.YYZACPI_swiginit(self, _QuantLib.new_YYZACPI(*args))
    __swig_destroy__ = _QuantLib.delete_YYZACPI

# Register YYZACPI in _QuantLib:
_QuantLib.YYZACPI_swigregister(YYZACPI)
class YYZACPIr(YoYInflationIndex):
    r"""Proxy of C++ YYZACPIr class."""

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

    def __init__(self, *args):
        r"""__init__(YYZACPIr self, bool interpolated, YoYInflationTermStructureHandle h={}) -> YYZACPIr"""
        _QuantLib.YYZACPIr_swiginit(self, _QuantLib.new_YYZACPIr(*args))
    __swig_destroy__ = _QuantLib.delete_YYZACPIr

# Register YYZACPIr in _QuantLib:
_QuantLib.YYZACPIr_swigregister(YYZACPIr)
class AUCPI(ZeroInflationIndex):
    r"""Proxy of C++ AUCPI class."""

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

    def __init__(self, *args):
        r"""
        __init__(AUCPI self, Frequency frequency, bool revised, ZeroInflationTermStructureHandle h={}) -> AUCPI
        __init__(AUCPI self, Frequency frequency, bool revised, bool interpolated, ZeroInflationTermStructureHandle h={}) -> AUCPI
        """
        _QuantLib.AUCPI_swiginit(self, _QuantLib.new_AUCPI(*args))
    __swig_destroy__ = _QuantLib.delete_AUCPI

# Register AUCPI in _QuantLib:
_QuantLib.AUCPI_swigregister(AUCPI)
class CPI(object):
    r"""Proxy of C++ CPI class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AsIndex = _QuantLib.CPI_AsIndex
    
    Flat = _QuantLib.CPI_Flat
    
    Linear = _QuantLib.CPI_Linear
    

    @staticmethod
    def laggedFixing(index, date, observationLag, interpolationType):
        r"""laggedFixing(ext::shared_ptr< ZeroInflationIndex > const & index, Date date, Period observationLag, CPI::InterpolationType interpolationType) -> Real"""
        return _QuantLib.CPI_laggedFixing(index, date, observationLag, interpolationType)

    def __init__(self):
        r"""__init__(CPI self) -> CPI"""
        _QuantLib.CPI_swiginit(self, _QuantLib.new_CPI())
    __swig_destroy__ = _QuantLib.delete_CPI

# Register CPI in _QuantLib:
_QuantLib.CPI_swigregister(CPI)
class InflationCoupon(Coupon):
    r"""Proxy of C++ InflationCoupon class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def fixingDate(self):
        r"""fixingDate(InflationCoupon self) -> Date"""
        return _QuantLib.InflationCoupon_fixingDate(self)

    def fixingDays(self):
        r"""fixingDays(InflationCoupon self) -> Integer"""
        return _QuantLib.InflationCoupon_fixingDays(self)

    def observationLag(self):
        r"""observationLag(InflationCoupon self) -> Period"""
        return _QuantLib.InflationCoupon_observationLag(self)

    def indexFixing(self):
        r"""indexFixing(InflationCoupon self) -> Rate"""
        return _QuantLib.InflationCoupon_indexFixing(self)

    def index(self):
        r"""index(InflationCoupon self) -> ext::shared_ptr< InflationIndex >"""
        return _QuantLib.InflationCoupon_index(self)
    __swig_destroy__ = _QuantLib.delete_InflationCoupon

# Register InflationCoupon in _QuantLib:
_QuantLib.InflationCoupon_swigregister(InflationCoupon)

def as_inflation_coupon(cf):
    r"""as_inflation_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< InflationCoupon >"""
    return _QuantLib.as_inflation_coupon(cf)
class CPICouponPricer(object):
    r"""Proxy of C++ CPICouponPricer class."""

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

    def __init__(self):
        r"""__init__(CPICouponPricer self) -> CPICouponPricer"""
        _QuantLib.CPICouponPricer_swiginit(self, _QuantLib.new_CPICouponPricer())
    __swig_destroy__ = _QuantLib.delete_CPICouponPricer

# Register CPICouponPricer in _QuantLib:
_QuantLib.CPICouponPricer_swigregister(CPICouponPricer)
class CPICoupon(InflationCoupon):
    r"""Proxy of C++ CPICoupon class."""

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

    def __init__(self, *args):
        r"""__init__(CPICoupon self, Real baseCPI, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date()) -> CPICoupon"""
        _QuantLib.CPICoupon_swiginit(self, _QuantLib.new_CPICoupon(*args))

    def fixedRate(self):
        r"""fixedRate(CPICoupon self) -> Rate"""
        return _QuantLib.CPICoupon_fixedRate(self)

    def spread(self):
        r"""spread(CPICoupon self) -> Spread"""
        return _QuantLib.CPICoupon_spread(self)

    def adjustedFixing(self):
        r"""adjustedFixing(CPICoupon self) -> Rate"""
        return _QuantLib.CPICoupon_adjustedFixing(self)

    def baseCPI(self):
        r"""baseCPI(CPICoupon self) -> Rate"""
        return _QuantLib.CPICoupon_baseCPI(self)

    def observationInterpolation(self):
        r"""observationInterpolation(CPICoupon self) -> CPI::InterpolationType"""
        return _QuantLib.CPICoupon_observationInterpolation(self)

    def cpiIndex(self):
        r"""cpiIndex(CPICoupon self) -> ext::shared_ptr< ZeroInflationIndex >"""
        return _QuantLib.CPICoupon_cpiIndex(self)

    def setPricer(self, arg2):
        r"""setPricer(CPICoupon self, ext::shared_ptr< CPICouponPricer > const & arg2)"""
        return _QuantLib.CPICoupon_setPricer(self, arg2)
    __swig_destroy__ = _QuantLib.delete_CPICoupon

# Register CPICoupon in _QuantLib:
_QuantLib.CPICoupon_swigregister(CPICoupon)

def as_cpi_coupon(cf):
    r"""as_cpi_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< CPICoupon >"""
    return _QuantLib.as_cpi_coupon(cf)
class CPICashFlow(IndexedCashFlow):
    r"""Proxy of C++ CPICashFlow class."""

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

    def __init__(self, *args):
        r"""__init__(CPICashFlow self, Real notional, ext::shared_ptr< ZeroInflationIndex > const & index, Date baseDate, Real baseFixing, Date fixingDate, Date paymentDate, bool growthOnly=False, CPI::InterpolationType interpolation=AsIndex, Frequency const & frequency=NoFrequency) -> CPICashFlow"""
        _QuantLib.CPICashFlow_swiginit(self, _QuantLib.new_CPICashFlow(*args))

    def interpolation(self):
        r"""interpolation(CPICashFlow self) -> CPI::InterpolationType"""
        return _QuantLib.CPICashFlow_interpolation(self)

    def frequency(self):
        r"""frequency(CPICashFlow self) -> Frequency"""
        return _QuantLib.CPICashFlow_frequency(self)
    __swig_destroy__ = _QuantLib.delete_CPICashFlow

# Register CPICashFlow in _QuantLib:
_QuantLib.CPICashFlow_swigregister(CPICashFlow)

def as_cpi_cashflow(cf):
    r"""as_cpi_cashflow(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< CPICashFlow >"""
    return _QuantLib.as_cpi_cashflow(cf)

def CPILeg(*args, **kwargs):
    r"""CPILeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< ZeroInflationIndex > const & index, Real baseCPI, Period observationLag, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, DoubleVector fixedRates=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, Calendar paymentCalendar=Calendar(), bool growthOnly=True, CPI::InterpolationType observationInterpolation=AsIndex) -> Leg"""
    return _QuantLib.CPILeg(*args, **kwargs)
class ZeroInflationCashFlow(CashFlow):
    r"""Proxy of C++ ZeroInflationCashFlow class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZeroInflationCashFlow self, Real notional, ext::shared_ptr< ZeroInflationIndex > const & index, CPI::InterpolationType observationInterpolation, Date startDate, Date endDate, Period observationLag, Date paymentDate, bool growthOnly=False) -> ZeroInflationCashFlow
        __init__(ZeroInflationCashFlow self, Real notional, ext::shared_ptr< ZeroInflationIndex > const & index, CPI::InterpolationType observationInterpolation, Date startDate, Date endDate, Period observationLag, Calendar calendar, BusinessDayConvention convention, Date paymentDate, bool growthOnly=False) -> ZeroInflationCashFlow
        """
        _QuantLib.ZeroInflationCashFlow_swiginit(self, _QuantLib.new_ZeroInflationCashFlow(*args))

    def notional(self):
        r"""notional(ZeroInflationCashFlow self) -> Real"""
        return _QuantLib.ZeroInflationCashFlow_notional(self)

    def baseDate(self):
        r"""baseDate(ZeroInflationCashFlow self) -> Date"""
        return _QuantLib.ZeroInflationCashFlow_baseDate(self)

    def fixingDate(self):
        r"""fixingDate(ZeroInflationCashFlow self) -> Date"""
        return _QuantLib.ZeroInflationCashFlow_fixingDate(self)

    def growthOnly(self):
        r"""growthOnly(ZeroInflationCashFlow self) -> bool"""
        return _QuantLib.ZeroInflationCashFlow_growthOnly(self)

    def observationInterpolation(self):
        r"""observationInterpolation(ZeroInflationCashFlow self) -> CPI::InterpolationType"""
        return _QuantLib.ZeroInflationCashFlow_observationInterpolation(self)

    def zeroInflationIndex(self):
        r"""zeroInflationIndex(ZeroInflationCashFlow self) -> ext::shared_ptr< ZeroInflationIndex >"""
        return _QuantLib.ZeroInflationCashFlow_zeroInflationIndex(self)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationCashFlow

# Register ZeroInflationCashFlow in _QuantLib:
_QuantLib.ZeroInflationCashFlow_swigregister(ZeroInflationCashFlow)

def as_zero_inflation_cash_flow(cf):
    r"""as_zero_inflation_cash_flow(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< ZeroInflationCashFlow >"""
    return _QuantLib.as_zero_inflation_cash_flow(cf)
class ZeroHelper(Observable):
    r"""Proxy of C++ BootstrapHelper< ZeroInflationTermStructure > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def quote(self):
        r"""quote(ZeroHelper self) -> QuoteHandle"""
        return _QuantLib.ZeroHelper_quote(self)

    def latestDate(self):
        r"""latestDate(ZeroHelper self) -> Date"""
        return _QuantLib.ZeroHelper_latestDate(self)

    def earliestDate(self):
        r"""earliestDate(ZeroHelper self) -> Date"""
        return _QuantLib.ZeroHelper_earliestDate(self)

    def maturityDate(self):
        r"""maturityDate(ZeroHelper self) -> Date"""
        return _QuantLib.ZeroHelper_maturityDate(self)

    def latestRelevantDate(self):
        r"""latestRelevantDate(ZeroHelper self) -> Date"""
        return _QuantLib.ZeroHelper_latestRelevantDate(self)

    def pillarDate(self):
        r"""pillarDate(ZeroHelper self) -> Date"""
        return _QuantLib.ZeroHelper_pillarDate(self)

    def impliedQuote(self):
        r"""impliedQuote(ZeroHelper self) -> Real"""
        return _QuantLib.ZeroHelper_impliedQuote(self)

    def quoteError(self):
        r"""quoteError(ZeroHelper self) -> Real"""
        return _QuantLib.ZeroHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_ZeroHelper

# Register ZeroHelper in _QuantLib:
_QuantLib.ZeroHelper_swigregister(ZeroHelper)
class YoYHelper(Observable):
    r"""Proxy of C++ BootstrapHelper< YoYInflationTermStructure > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def quote(self):
        r"""quote(YoYHelper self) -> QuoteHandle"""
        return _QuantLib.YoYHelper_quote(self)

    def latestDate(self):
        r"""latestDate(YoYHelper self) -> Date"""
        return _QuantLib.YoYHelper_latestDate(self)

    def earliestDate(self):
        r"""earliestDate(YoYHelper self) -> Date"""
        return _QuantLib.YoYHelper_earliestDate(self)

    def maturityDate(self):
        r"""maturityDate(YoYHelper self) -> Date"""
        return _QuantLib.YoYHelper_maturityDate(self)

    def latestRelevantDate(self):
        r"""latestRelevantDate(YoYHelper self) -> Date"""
        return _QuantLib.YoYHelper_latestRelevantDate(self)

    def pillarDate(self):
        r"""pillarDate(YoYHelper self) -> Date"""
        return _QuantLib.YoYHelper_pillarDate(self)

    def impliedQuote(self):
        r"""impliedQuote(YoYHelper self) -> Real"""
        return _QuantLib.YoYHelper_impliedQuote(self)

    def quoteError(self):
        r"""quoteError(YoYHelper self) -> Real"""
        return _QuantLib.YoYHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_YoYHelper

# Register YoYHelper in _QuantLib:
_QuantLib.YoYHelper_swigregister(YoYHelper)
class YoYOptionHelper(Observable):
    r"""Proxy of C++ BootstrapHelper< YoYOptionletVolatilitySurface > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def quote(self):
        r"""quote(YoYOptionHelper self) -> QuoteHandle"""
        return _QuantLib.YoYOptionHelper_quote(self)

    def latestDate(self):
        r"""latestDate(YoYOptionHelper self) -> Date"""
        return _QuantLib.YoYOptionHelper_latestDate(self)

    def earliestDate(self):
        r"""earliestDate(YoYOptionHelper self) -> Date"""
        return _QuantLib.YoYOptionHelper_earliestDate(self)

    def maturityDate(self):
        r"""maturityDate(YoYOptionHelper self) -> Date"""
        return _QuantLib.YoYOptionHelper_maturityDate(self)

    def latestRelevantDate(self):
        r"""latestRelevantDate(YoYOptionHelper self) -> Date"""
        return _QuantLib.YoYOptionHelper_latestRelevantDate(self)

    def pillarDate(self):
        r"""pillarDate(YoYOptionHelper self) -> Date"""
        return _QuantLib.YoYOptionHelper_pillarDate(self)

    def impliedQuote(self):
        r"""impliedQuote(YoYOptionHelper self) -> Real"""
        return _QuantLib.YoYOptionHelper_impliedQuote(self)

    def quoteError(self):
        r"""quoteError(YoYOptionHelper self) -> Real"""
        return _QuantLib.YoYOptionHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_YoYOptionHelper

# Register YoYOptionHelper in _QuantLib:
_QuantLib.YoYOptionHelper_swigregister(YoYOptionHelper)
class ZeroHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > class."""

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

    def iterator(self):
        r"""iterator(ZeroHelperVector self) -> SwigPyIterator"""
        return _QuantLib.ZeroHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ZeroHelperVector self) -> bool"""
        return _QuantLib.ZeroHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ZeroHelperVector self) -> bool"""
        return _QuantLib.ZeroHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type"""
        return _QuantLib.ZeroHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j) -> ZeroHelperVector"""
        return _QuantLib.ZeroHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j)
        __setslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j, ZeroHelperVector v)
        """
        return _QuantLib.ZeroHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j)"""
        return _QuantLib.ZeroHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i)
        __delitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.ZeroHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice) -> ZeroHelperVector
        __getitem__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &
        """
        return _QuantLib.ZeroHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice, ZeroHelperVector v)
        __setitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)
        """
        return _QuantLib.ZeroHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type"""
        return _QuantLib.ZeroHelperVector_pop(self)

    def append(self, x):
        r"""append(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)"""
        return _QuantLib.ZeroHelperVector_append(self, x)

    def empty(self):
        r"""empty(ZeroHelperVector self) -> bool"""
        return _QuantLib.ZeroHelperVector_empty(self)

    def size(self):
        r"""size(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type"""
        return _QuantLib.ZeroHelperVector_size(self)

    def swap(self, v):
        r"""swap(ZeroHelperVector self, ZeroHelperVector v)"""
        return _QuantLib.ZeroHelperVector_swap(self, v)

    def begin(self):
        r"""begin(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator"""
        return _QuantLib.ZeroHelperVector_begin(self)

    def end(self):
        r"""end(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator"""
        return _QuantLib.ZeroHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator"""
        return _QuantLib.ZeroHelperVector_rbegin(self)

    def rend(self):
        r"""rend(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator"""
        return _QuantLib.ZeroHelperVector_rend(self)

    def clear(self):
        r"""clear(ZeroHelperVector self)"""
        return _QuantLib.ZeroHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::allocator_type"""
        return _QuantLib.ZeroHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ZeroHelperVector self)"""
        return _QuantLib.ZeroHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator
        erase(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator first, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator last) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator
        """
        return _QuantLib.ZeroHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ZeroHelperVector self) -> ZeroHelperVector
        __init__(ZeroHelperVector self, ZeroHelperVector other) -> ZeroHelperVector
        __init__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type size) -> ZeroHelperVector
        __init__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type size, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & value) -> ZeroHelperVector
        """
        _QuantLib.ZeroHelperVector_swiginit(self, _QuantLib.new_ZeroHelperVector(*args))

    def push_back(self, x):
        r"""push_back(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)"""
        return _QuantLib.ZeroHelperVector_push_back(self, x)

    def front(self):
        r"""front(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &"""
        return _QuantLib.ZeroHelperVector_front(self)

    def back(self):
        r"""back(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &"""
        return _QuantLib.ZeroHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)"""
        return _QuantLib.ZeroHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type new_size)
        resize(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type new_size, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)
        """
        return _QuantLib.ZeroHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator
        insert(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)
        """
        return _QuantLib.ZeroHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n)"""
        return _QuantLib.ZeroHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type"""
        return _QuantLib.ZeroHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_ZeroHelperVector

# Register ZeroHelperVector in _QuantLib:
_QuantLib.ZeroHelperVector_swigregister(ZeroHelperVector)
class YoYHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > class."""

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

    def iterator(self):
        r"""iterator(YoYHelperVector self) -> SwigPyIterator"""
        return _QuantLib.YoYHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(YoYHelperVector self) -> bool"""
        return _QuantLib.YoYHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(YoYHelperVector self) -> bool"""
        return _QuantLib.YoYHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type"""
        return _QuantLib.YoYHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j) -> YoYHelperVector"""
        return _QuantLib.YoYHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j)
        __setslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j, YoYHelperVector v)
        """
        return _QuantLib.YoYHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j)"""
        return _QuantLib.YoYHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i)
        __delitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.YoYHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice) -> YoYHelperVector
        __getitem__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &
        """
        return _QuantLib.YoYHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice, YoYHelperVector v)
        __setitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)
        """
        return _QuantLib.YoYHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type"""
        return _QuantLib.YoYHelperVector_pop(self)

    def append(self, x):
        r"""append(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)"""
        return _QuantLib.YoYHelperVector_append(self, x)

    def empty(self):
        r"""empty(YoYHelperVector self) -> bool"""
        return _QuantLib.YoYHelperVector_empty(self)

    def size(self):
        r"""size(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type"""
        return _QuantLib.YoYHelperVector_size(self)

    def swap(self, v):
        r"""swap(YoYHelperVector self, YoYHelperVector v)"""
        return _QuantLib.YoYHelperVector_swap(self, v)

    def begin(self):
        r"""begin(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator"""
        return _QuantLib.YoYHelperVector_begin(self)

    def end(self):
        r"""end(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator"""
        return _QuantLib.YoYHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator"""
        return _QuantLib.YoYHelperVector_rbegin(self)

    def rend(self):
        r"""rend(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator"""
        return _QuantLib.YoYHelperVector_rend(self)

    def clear(self):
        r"""clear(YoYHelperVector self)"""
        return _QuantLib.YoYHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::allocator_type"""
        return _QuantLib.YoYHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(YoYHelperVector self)"""
        return _QuantLib.YoYHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator
        erase(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator first, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator last) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator
        """
        return _QuantLib.YoYHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(YoYHelperVector self) -> YoYHelperVector
        __init__(YoYHelperVector self, YoYHelperVector other) -> YoYHelperVector
        __init__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type size) -> YoYHelperVector
        __init__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type size, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & value) -> YoYHelperVector
        """
        _QuantLib.YoYHelperVector_swiginit(self, _QuantLib.new_YoYHelperVector(*args))

    def push_back(self, x):
        r"""push_back(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)"""
        return _QuantLib.YoYHelperVector_push_back(self, x)

    def front(self):
        r"""front(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &"""
        return _QuantLib.YoYHelperVector_front(self)

    def back(self):
        r"""back(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &"""
        return _QuantLib.YoYHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)"""
        return _QuantLib.YoYHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type new_size)
        resize(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type new_size, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)
        """
        return _QuantLib.YoYHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator
        insert(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)
        """
        return _QuantLib.YoYHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n)"""
        return _QuantLib.YoYHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type"""
        return _QuantLib.YoYHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_YoYHelperVector

# Register YoYHelperVector in _QuantLib:
_QuantLib.YoYHelperVector_swigregister(YoYHelperVector)
class YoYOptionHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > class."""

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

    def iterator(self):
        r"""iterator(YoYOptionHelperVector self) -> SwigPyIterator"""
        return _QuantLib.YoYOptionHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(YoYOptionHelperVector self) -> bool"""
        return _QuantLib.YoYOptionHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(YoYOptionHelperVector self) -> bool"""
        return _QuantLib.YoYOptionHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type"""
        return _QuantLib.YoYOptionHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j) -> YoYOptionHelperVector"""
        return _QuantLib.YoYOptionHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j)
        __setslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j, YoYOptionHelperVector v)
        """
        return _QuantLib.YoYOptionHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j)"""
        return _QuantLib.YoYOptionHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i)
        __delitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.YoYOptionHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice) -> YoYOptionHelperVector
        __getitem__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &
        """
        return _QuantLib.YoYOptionHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice, YoYOptionHelperVector v)
        __setitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)
        """
        return _QuantLib.YoYOptionHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type"""
        return _QuantLib.YoYOptionHelperVector_pop(self)

    def append(self, x):
        r"""append(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)"""
        return _QuantLib.YoYOptionHelperVector_append(self, x)

    def empty(self):
        r"""empty(YoYOptionHelperVector self) -> bool"""
        return _QuantLib.YoYOptionHelperVector_empty(self)

    def size(self):
        r"""size(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type"""
        return _QuantLib.YoYOptionHelperVector_size(self)

    def swap(self, v):
        r"""swap(YoYOptionHelperVector self, YoYOptionHelperVector v)"""
        return _QuantLib.YoYOptionHelperVector_swap(self, v)

    def begin(self):
        r"""begin(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator"""
        return _QuantLib.YoYOptionHelperVector_begin(self)

    def end(self):
        r"""end(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator"""
        return _QuantLib.YoYOptionHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator"""
        return _QuantLib.YoYOptionHelperVector_rbegin(self)

    def rend(self):
        r"""rend(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator"""
        return _QuantLib.YoYOptionHelperVector_rend(self)

    def clear(self):
        r"""clear(YoYOptionHelperVector self)"""
        return _QuantLib.YoYOptionHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::allocator_type"""
        return _QuantLib.YoYOptionHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(YoYOptionHelperVector self)"""
        return _QuantLib.YoYOptionHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator
        erase(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator first, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator last) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator
        """
        return _QuantLib.YoYOptionHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(YoYOptionHelperVector self) -> YoYOptionHelperVector
        __init__(YoYOptionHelperVector self, YoYOptionHelperVector other) -> YoYOptionHelperVector
        __init__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type size) -> YoYOptionHelperVector
        __init__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type size, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & value) -> YoYOptionHelperVector
        """
        _QuantLib.YoYOptionHelperVector_swiginit(self, _QuantLib.new_YoYOptionHelperVector(*args))

    def push_back(self, x):
        r"""push_back(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)"""
        return _QuantLib.YoYOptionHelperVector_push_back(self, x)

    def front(self):
        r"""front(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &"""
        return _QuantLib.YoYOptionHelperVector_front(self)

    def back(self):
        r"""back(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &"""
        return _QuantLib.YoYOptionHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)"""
        return _QuantLib.YoYOptionHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type new_size)
        resize(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type new_size, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)
        """
        return _QuantLib.YoYOptionHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator
        insert(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)
        """
        return _QuantLib.YoYOptionHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n)"""
        return _QuantLib.YoYOptionHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type"""
        return _QuantLib.YoYOptionHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_YoYOptionHelperVector

# Register YoYOptionHelperVector in _QuantLib:
_QuantLib.YoYOptionHelperVector_swigregister(YoYOptionHelperVector)
class ZeroCouponInflationSwapHelper(ZeroHelper):
    r"""Proxy of C++ ZeroCouponInflationSwapHelper class."""

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

    def __init__(self, quote, lag, maturity, calendar, bcd, dayCounter, index, observationInterpolation, nominalTS):
        r"""__init__(ZeroCouponInflationSwapHelper self, QuoteHandle quote, Period lag, Date maturity, Calendar calendar, BusinessDayConvention bcd, DayCounter dayCounter, ext::shared_ptr< ZeroInflationIndex > const & index, CPI::InterpolationType observationInterpolation, YieldTermStructureHandle nominalTS) -> ZeroCouponInflationSwapHelper"""
        _QuantLib.ZeroCouponInflationSwapHelper_swiginit(self, _QuantLib.new_ZeroCouponInflationSwapHelper(quote, lag, maturity, calendar, bcd, dayCounter, index, observationInterpolation, nominalTS))
    __swig_destroy__ = _QuantLib.delete_ZeroCouponInflationSwapHelper

# Register ZeroCouponInflationSwapHelper in _QuantLib:
_QuantLib.ZeroCouponInflationSwapHelper_swigregister(ZeroCouponInflationSwapHelper)
class YearOnYearInflationSwapHelper(YoYHelper):
    r"""Proxy of C++ YearOnYearInflationSwapHelper class."""

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

    def __init__(self, quote, lag, maturity, calendar, bdc, dayCounter, index, nominalTS):
        r"""__init__(YearOnYearInflationSwapHelper self, QuoteHandle quote, Period lag, Date maturity, Calendar calendar, BusinessDayConvention bdc, DayCounter dayCounter, ext::shared_ptr< YoYInflationIndex > const & index, YieldTermStructureHandle nominalTS) -> YearOnYearInflationSwapHelper"""
        _QuantLib.YearOnYearInflationSwapHelper_swiginit(self, _QuantLib.new_YearOnYearInflationSwapHelper(quote, lag, maturity, calendar, bdc, dayCounter, index, nominalTS))
    __swig_destroy__ = _QuantLib.delete_YearOnYearInflationSwapHelper

# Register YearOnYearInflationSwapHelper in _QuantLib:
_QuantLib.YearOnYearInflationSwapHelper_swigregister(YearOnYearInflationSwapHelper)
class PiecewiseZeroInflation(ZeroInflationTermStructure):
    r"""Proxy of C++ PiecewiseZeroInflationCurve< Linear > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PiecewiseZeroInflation self, Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, Rate baseRate, ZeroHelperVector instruments, Real accuracy=1.0e-12, Linear i=Linear()) -> PiecewiseZeroInflation
        __init__(PiecewiseZeroInflation self, Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, bool indexIsInterpolated, Rate baseRate, ZeroHelperVector instruments, Real accuracy=1.0e-12, Linear i=Linear()) -> PiecewiseZeroInflation
        """
        _QuantLib.PiecewiseZeroInflation_swiginit(self, _QuantLib.new_PiecewiseZeroInflation(*args))

    def dates(self):
        r"""dates(PiecewiseZeroInflation self) -> DateVector"""
        return _QuantLib.PiecewiseZeroInflation_dates(self)

    def times(self):
        r"""times(PiecewiseZeroInflation self) -> DoubleVector"""
        return _QuantLib.PiecewiseZeroInflation_times(self)

    def nodes(self):
        r"""nodes(PiecewiseZeroInflation self) -> NodeVector"""
        return _QuantLib.PiecewiseZeroInflation_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseZeroInflation

# Register PiecewiseZeroInflation in _QuantLib:
_QuantLib.PiecewiseZeroInflation_swigregister(PiecewiseZeroInflation)
class PiecewiseYoYInflation(YoYInflationTermStructure):
    r"""Proxy of C++ PiecewiseYoYInflationCurve< Linear > class."""

    thisown = 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):
        r"""__init__(PiecewiseYoYInflation self, Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, bool indexIsInterpolated, Rate baseRate, YoYHelperVector instruments, Real accuracy=1.0e-12, Linear i=Linear()) -> PiecewiseYoYInflation"""
        _QuantLib.PiecewiseYoYInflation_swiginit(self, _QuantLib.new_PiecewiseYoYInflation(*args, **kwargs))

    def dates(self):
        r"""dates(PiecewiseYoYInflation self) -> DateVector"""
        return _QuantLib.PiecewiseYoYInflation_dates(self)

    def times(self):
        r"""times(PiecewiseYoYInflation self) -> DoubleVector"""
        return _QuantLib.PiecewiseYoYInflation_times(self)

    def nodes(self):
        r"""nodes(PiecewiseYoYInflation self) -> NodeVector"""
        return _QuantLib.PiecewiseYoYInflation_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseYoYInflation

# Register PiecewiseYoYInflation in _QuantLib:
_QuantLib.PiecewiseYoYInflation_swigregister(PiecewiseYoYInflation)
class DatePair(object):
    r"""Proxy of C++ std::pair< Date,Date > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DatePair self) -> DatePair
        __init__(DatePair self, Date first, Date second) -> DatePair
        __init__(DatePair self, DatePair other) -> DatePair
        """
        _QuantLib.DatePair_swiginit(self, _QuantLib.new_DatePair(*args))
    first = property(_QuantLib.DatePair_first_get, _QuantLib.DatePair_first_set, doc=r"""first : Date""")
    second = property(_QuantLib.DatePair_second_get, _QuantLib.DatePair_second_set, doc=r"""second : Date""")
    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_DatePair

# Register DatePair in _QuantLib:
_QuantLib.DatePair_swigregister(DatePair)

def inflationPeriod(d, f):
    r"""inflationPeriod(Date d, Frequency f) -> DatePair"""
    return _QuantLib.inflationPeriod(d, f)

def inflationYearFraction(f, indexIsInterpolated, dayCount, d1, d2):
    r"""inflationYearFraction(Frequency f, bool indexIsInterpolated, DayCounter dayCount, Date d1, Date d2) -> Time"""
    return _QuantLib.inflationYearFraction(f, indexIsInterpolated, dayCount, d1, d2)

def inflationBaseDate(referenceDate, observationLag, frequency, indexIsInterpolated):
    r"""inflationBaseDate(Date referenceDate, Period observationLag, Frequency frequency, bool indexIsInterpolated) -> Date"""
    return _QuantLib.inflationBaseDate(referenceDate, observationLag, frequency, indexIsInterpolated)
class YoYInflationCouponPricer(object):
    r"""Proxy of C++ YoYInflationCouponPricer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register YoYInflationCouponPricer in _QuantLib:
_QuantLib.YoYInflationCouponPricer_swigregister(YoYInflationCouponPricer)

def setCouponPricer(*args):
    r"""
    setCouponPricer(Leg arg1, ext::shared_ptr< FloatingRateCouponPricer > const & arg2)
    setCouponPricer(Leg arg1, ext::shared_ptr< YoYInflationCouponPricer > const & arg2)
    """
    return _QuantLib.setCouponPricer(*args)
class YoYInflationCoupon(InflationCoupon):
    r"""Proxy of C++ YoYInflationCoupon class."""

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

    def __init__(self, *args):
        r"""__init__(YoYInflationCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< YoYInflationIndex > const & index, Period observationLag, DayCounter dayCounter, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date()) -> YoYInflationCoupon"""
        _QuantLib.YoYInflationCoupon_swiginit(self, _QuantLib.new_YoYInflationCoupon(*args))

    def gearing(self):
        r"""gearing(YoYInflationCoupon self) -> Real"""
        return _QuantLib.YoYInflationCoupon_gearing(self)

    def spread(self):
        r"""spread(YoYInflationCoupon self) -> Spread"""
        return _QuantLib.YoYInflationCoupon_spread(self)

    def adjustedFixing(self):
        r"""adjustedFixing(YoYInflationCoupon self) -> Rate"""
        return _QuantLib.YoYInflationCoupon_adjustedFixing(self)

    def yoyIndex(self):
        r"""yoyIndex(YoYInflationCoupon self) -> ext::shared_ptr< YoYInflationIndex >"""
        return _QuantLib.YoYInflationCoupon_yoyIndex(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationCoupon

# Register YoYInflationCoupon in _QuantLib:
_QuantLib.YoYInflationCoupon_swigregister(YoYInflationCoupon)

def as_yoy_inflation_coupon(cf):
    r"""as_yoy_inflation_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< YoYInflationCoupon >"""
    return _QuantLib.as_yoy_inflation_coupon(cf)
class CappedFlooredYoYInflationCoupon(YoYInflationCoupon):
    r"""Proxy of C++ CappedFlooredYoYInflationCoupon class."""

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

    def __init__(self, *args):
        r"""__init__(CappedFlooredYoYInflationCoupon self, Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< YoYInflationIndex > const & index, Period observationLag, DayCounter dayCounter, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date()) -> CappedFlooredYoYInflationCoupon"""
        _QuantLib.CappedFlooredYoYInflationCoupon_swiginit(self, _QuantLib.new_CappedFlooredYoYInflationCoupon(*args))

    def rate(self):
        r"""rate(CappedFlooredYoYInflationCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_rate(self)

    def cap(self):
        r"""cap(CappedFlooredYoYInflationCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_cap(self)

    def floor(self):
        r"""floor(CappedFlooredYoYInflationCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_floor(self)

    def effectiveCap(self):
        r"""effectiveCap(CappedFlooredYoYInflationCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_effectiveCap(self)

    def effectiveFloor(self):
        r"""effectiveFloor(CappedFlooredYoYInflationCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_effectiveFloor(self)

    def underlyingRate(self):
        r"""underlyingRate(CappedFlooredYoYInflationCoupon self) -> Rate"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_underlyingRate(self)

    def isCapped(self):
        r"""isCapped(CappedFlooredYoYInflationCoupon self) -> bool"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_isCapped(self)

    def isFloored(self):
        r"""isFloored(CappedFlooredYoYInflationCoupon self) -> bool"""
        return _QuantLib.CappedFlooredYoYInflationCoupon_isFloored(self)
    __swig_destroy__ = _QuantLib.delete_CappedFlooredYoYInflationCoupon

# Register CappedFlooredYoYInflationCoupon in _QuantLib:
_QuantLib.CappedFlooredYoYInflationCoupon_swigregister(CappedFlooredYoYInflationCoupon)

def as_capped_floored_yoy_inflation_coupon(cf):
    r"""as_capped_floored_yoy_inflation_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< CappedFlooredYoYInflationCoupon >"""
    return _QuantLib.as_capped_floored_yoy_inflation_coupon(cf)

def yoyInflationLeg(*args, **kwargs):
    r"""yoyInflationLeg(Schedule schedule, Calendar calendar, ext::shared_ptr< YoYInflationIndex > const & index, Period observationLag, DoubleVector notionals, DayCounter paymentDayCounter, BusinessDayConvention paymentAdjustment=Following, Natural fixingDays=0, DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >()) -> Leg"""
    return _QuantLib.yoyInflationLeg(*args, **kwargs)
class BlackYoYInflationCouponPricer(YoYInflationCouponPricer):
    r"""Proxy of C++ BlackYoYInflationCouponPricer class."""

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

    def __init__(self, capletVol, nominalTermStructure):
        r"""__init__(BlackYoYInflationCouponPricer self, YoYOptionletVolatilitySurfaceHandle capletVol, YieldTermStructureHandle nominalTermStructure) -> BlackYoYInflationCouponPricer"""
        _QuantLib.BlackYoYInflationCouponPricer_swiginit(self, _QuantLib.new_BlackYoYInflationCouponPricer(capletVol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_BlackYoYInflationCouponPricer

# Register BlackYoYInflationCouponPricer in _QuantLib:
_QuantLib.BlackYoYInflationCouponPricer_swigregister(BlackYoYInflationCouponPricer)
class UnitDisplacedBlackYoYInflationCouponPricer(YoYInflationCouponPricer):
    r"""Proxy of C++ UnitDisplacedBlackYoYInflationCouponPricer class."""

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

    def __init__(self, capletVol, nominalTermStructure):
        r"""__init__(UnitDisplacedBlackYoYInflationCouponPricer self, YoYOptionletVolatilitySurfaceHandle capletVol, YieldTermStructureHandle nominalTermStructure) -> UnitDisplacedBlackYoYInflationCouponPricer"""
        _QuantLib.UnitDisplacedBlackYoYInflationCouponPricer_swiginit(self, _QuantLib.new_UnitDisplacedBlackYoYInflationCouponPricer(capletVol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_UnitDisplacedBlackYoYInflationCouponPricer

# Register UnitDisplacedBlackYoYInflationCouponPricer in _QuantLib:
_QuantLib.UnitDisplacedBlackYoYInflationCouponPricer_swigregister(UnitDisplacedBlackYoYInflationCouponPricer)
class BachelierYoYInflationCouponPricer(YoYInflationCouponPricer):
    r"""Proxy of C++ BachelierYoYInflationCouponPricer class."""

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

    def __init__(self, capletVol, nominalTermStructure):
        r"""__init__(BachelierYoYInflationCouponPricer self, YoYOptionletVolatilitySurfaceHandle capletVol, YieldTermStructureHandle nominalTermStructure) -> BachelierYoYInflationCouponPricer"""
        _QuantLib.BachelierYoYInflationCouponPricer_swiginit(self, _QuantLib.new_BachelierYoYInflationCouponPricer(capletVol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_BachelierYoYInflationCouponPricer

# Register BachelierYoYInflationCouponPricer in _QuantLib:
_QuantLib.BachelierYoYInflationCouponPricer_swigregister(BachelierYoYInflationCouponPricer)
class ZeroCouponInflationSwap(Swap):
    r"""Proxy of C++ ZeroCouponInflationSwap class."""

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

    def __init__(self, *args):
        r"""__init__(ZeroCouponInflationSwap self, Swap::Type type, Real nominal, Date start, Date maturity, Calendar calendar, BusinessDayConvention convention, DayCounter dayCounter, Rate fixedRate, ext::shared_ptr< ZeroInflationIndex > const & index, Period lag, CPI::InterpolationType observationInterpolation, bool adjustInfObsDates=False, Calendar infCalendar=Calendar(), BusinessDayConvention infConvention=BusinessDayConvention()) -> ZeroCouponInflationSwap"""
        _QuantLib.ZeroCouponInflationSwap_swiginit(self, _QuantLib.new_ZeroCouponInflationSwap(*args))

    def fairRate(self):
        r"""fairRate(ZeroCouponInflationSwap self) -> Rate"""
        return _QuantLib.ZeroCouponInflationSwap_fairRate(self)

    def fixedLegNPV(self):
        r"""fixedLegNPV(ZeroCouponInflationSwap self) -> Real"""
        return _QuantLib.ZeroCouponInflationSwap_fixedLegNPV(self)

    def inflationLegNPV(self):
        r"""inflationLegNPV(ZeroCouponInflationSwap self) -> Real"""
        return _QuantLib.ZeroCouponInflationSwap_inflationLegNPV(self)

    def fixedLeg(self):
        r"""fixedLeg(ZeroCouponInflationSwap self) -> Leg"""
        return _QuantLib.ZeroCouponInflationSwap_fixedLeg(self)

    def inflationLeg(self):
        r"""inflationLeg(ZeroCouponInflationSwap self) -> Leg"""
        return _QuantLib.ZeroCouponInflationSwap_inflationLeg(self)

    def type(self):
        r"""type(ZeroCouponInflationSwap self) -> Swap::Type"""
        return _QuantLib.ZeroCouponInflationSwap_type(self)
    __swig_destroy__ = _QuantLib.delete_ZeroCouponInflationSwap

# Register ZeroCouponInflationSwap in _QuantLib:
_QuantLib.ZeroCouponInflationSwap_swigregister(ZeroCouponInflationSwap)
class YearOnYearInflationSwap(Swap):
    r"""Proxy of C++ YearOnYearInflationSwap class."""

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

    def __init__(self, type, nominal, fixedSchedule, fixedRate, fixedDayCounter, yoySchedule, index, lag, spread, yoyDayCounter, paymentCalendar, paymentConvention=Following):
        r"""__init__(YearOnYearInflationSwap self, Swap::Type type, Real nominal, Schedule fixedSchedule, Rate fixedRate, DayCounter fixedDayCounter, Schedule yoySchedule, ext::shared_ptr< YoYInflationIndex > const & index, Period lag, Spread spread, DayCounter yoyDayCounter, Calendar paymentCalendar, BusinessDayConvention paymentConvention=Following) -> YearOnYearInflationSwap"""
        _QuantLib.YearOnYearInflationSwap_swiginit(self, _QuantLib.new_YearOnYearInflationSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCounter, yoySchedule, index, lag, spread, yoyDayCounter, paymentCalendar, paymentConvention))

    def fairRate(self):
        r"""fairRate(YearOnYearInflationSwap self) -> Rate"""
        return _QuantLib.YearOnYearInflationSwap_fairRate(self)

    def fixedLegNPV(self):
        r"""fixedLegNPV(YearOnYearInflationSwap self) -> Real"""
        return _QuantLib.YearOnYearInflationSwap_fixedLegNPV(self)

    def yoyLegNPV(self):
        r"""yoyLegNPV(YearOnYearInflationSwap self) -> Real"""
        return _QuantLib.YearOnYearInflationSwap_yoyLegNPV(self)

    def fairSpread(self):
        r"""fairSpread(YearOnYearInflationSwap self) -> Spread"""
        return _QuantLib.YearOnYearInflationSwap_fairSpread(self)

    def fixedLeg(self):
        r"""fixedLeg(YearOnYearInflationSwap self) -> Leg"""
        return _QuantLib.YearOnYearInflationSwap_fixedLeg(self)

    def yoyLeg(self):
        r"""yoyLeg(YearOnYearInflationSwap self) -> Leg"""
        return _QuantLib.YearOnYearInflationSwap_yoyLeg(self)
    __swig_destroy__ = _QuantLib.delete_YearOnYearInflationSwap

# Register YearOnYearInflationSwap in _QuantLib:
_QuantLib.YearOnYearInflationSwap_swigregister(YearOnYearInflationSwap)
class CPISwap(Swap):
    r"""Proxy of C++ CPISwap class."""

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

    def __init__(self, *args):
        r"""__init__(CPISwap self, Swap::Type type, Real nominal, bool subtractInflationNominal, Spread spread, DayCounter floatDayCount, Schedule floatSchedule, BusinessDayConvention const & floatRoll, Natural fixingDays, ext::shared_ptr< IborIndex > const & floatIndex, Rate fixedRate, Real baseCPI, DayCounter fixedDayCount, Schedule fixedSchedule, BusinessDayConvention const & fixedRoll, Period observationLag, ext::shared_ptr< ZeroInflationIndex > const & fixedIndex, CPI::InterpolationType observationInterpolation=AsIndex, Real inflationNominal=Null< Real >()) -> CPISwap"""
        _QuantLib.CPISwap_swiginit(self, _QuantLib.new_CPISwap(*args))

    def fairRate(self):
        r"""fairRate(CPISwap self) -> Rate"""
        return _QuantLib.CPISwap_fairRate(self)

    def floatLegNPV(self):
        r"""floatLegNPV(CPISwap self) -> Real"""
        return _QuantLib.CPISwap_floatLegNPV(self)

    def fairSpread(self):
        r"""fairSpread(CPISwap self) -> Spread"""
        return _QuantLib.CPISwap_fairSpread(self)

    def fixedLegNPV(self):
        r"""fixedLegNPV(CPISwap self) -> Real"""
        return _QuantLib.CPISwap_fixedLegNPV(self)

    def cpiLeg(self):
        r"""cpiLeg(CPISwap self) -> Leg"""
        return _QuantLib.CPISwap_cpiLeg(self)

    def floatLeg(self):
        r"""floatLeg(CPISwap self) -> Leg"""
        return _QuantLib.CPISwap_floatLeg(self)
    __swig_destroy__ = _QuantLib.delete_CPISwap

# Register CPISwap in _QuantLib:
_QuantLib.CPISwap_swigregister(CPISwap)
class YoYInflationCapFloor(Instrument):
    r"""Proxy of C++ YoYInflationCapFloor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Cap = _QuantLib.YoYInflationCapFloor_Cap
    
    Floor = _QuantLib.YoYInflationCapFloor_Floor
    
    Collar = _QuantLib.YoYInflationCapFloor_Collar
    

    def __init__(self, type, yoyLeg, strikes):
        r"""__init__(YoYInflationCapFloor self, YoYInflationCapFloor::Type type, Leg yoyLeg, DoubleVector strikes) -> YoYInflationCapFloor"""
        _QuantLib.YoYInflationCapFloor_swiginit(self, _QuantLib.new_YoYInflationCapFloor(type, yoyLeg, strikes))

    def impliedVolatility(self, price, curve, guess, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0):
        r"""impliedVolatility(YoYInflationCapFloor self, Real price, YoYInflationTermStructureHandle curve, Volatility guess, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0) -> Volatility"""
        return _QuantLib.YoYInflationCapFloor_impliedVolatility(self, price, curve, guess, accuracy, maxEvaluations, minVol, maxVol)

    def optionletPrices(self):
        r"""optionletPrices(YoYInflationCapFloor self) -> DoubleVector"""
        return _QuantLib.YoYInflationCapFloor_optionletPrices(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationCapFloor

# Register YoYInflationCapFloor in _QuantLib:
_QuantLib.YoYInflationCapFloor_swigregister(YoYInflationCapFloor)
class YoYInflationCap(YoYInflationCapFloor):
    r"""Proxy of C++ YoYInflationCap class."""

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

    def __init__(self, leg, capRates):
        r"""__init__(YoYInflationCap self, Leg leg, DoubleVector capRates) -> YoYInflationCap"""
        _QuantLib.YoYInflationCap_swiginit(self, _QuantLib.new_YoYInflationCap(leg, capRates))
    __swig_destroy__ = _QuantLib.delete_YoYInflationCap

# Register YoYInflationCap in _QuantLib:
_QuantLib.YoYInflationCap_swigregister(YoYInflationCap)
class YoYInflationFloor(YoYInflationCapFloor):
    r"""Proxy of C++ YoYInflationFloor class."""

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

    def __init__(self, leg, floorRates):
        r"""__init__(YoYInflationFloor self, Leg leg, DoubleVector floorRates) -> YoYInflationFloor"""
        _QuantLib.YoYInflationFloor_swiginit(self, _QuantLib.new_YoYInflationFloor(leg, floorRates))
    __swig_destroy__ = _QuantLib.delete_YoYInflationFloor

# Register YoYInflationFloor in _QuantLib:
_QuantLib.YoYInflationFloor_swigregister(YoYInflationFloor)
class YoYInflationCollar(YoYInflationCapFloor):
    r"""Proxy of C++ YoYInflationCollar class."""

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

    def __init__(self, leg, capRates, floorRates):
        r"""__init__(YoYInflationCollar self, Leg leg, DoubleVector capRates, DoubleVector floorRates) -> YoYInflationCollar"""
        _QuantLib.YoYInflationCollar_swiginit(self, _QuantLib.new_YoYInflationCollar(leg, capRates, floorRates))
    __swig_destroy__ = _QuantLib.delete_YoYInflationCollar

# Register YoYInflationCollar in _QuantLib:
_QuantLib.YoYInflationCollar_swigregister(YoYInflationCollar)
class ZeroInflationCurve(ZeroInflationTermStructure):
    r"""Proxy of C++ InterpolatedZeroInflationCurve< Linear > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ZeroInflationCurve self, Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, DateVector dates, DoubleVector rates, Linear interpolator=Linear()) -> ZeroInflationCurve
        __init__(ZeroInflationCurve self, Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, bool indexIsInterpolated, DateVector dates, DoubleVector rates, Linear interpolator=Linear()) -> ZeroInflationCurve
        """
        _QuantLib.ZeroInflationCurve_swiginit(self, _QuantLib.new_ZeroInflationCurve(*args))

    def dates(self):
        r"""dates(ZeroInflationCurve self) -> DateVector"""
        return _QuantLib.ZeroInflationCurve_dates(self)

    def times(self):
        r"""times(ZeroInflationCurve self) -> DoubleVector"""
        return _QuantLib.ZeroInflationCurve_times(self)

    def data(self):
        r"""data(ZeroInflationCurve self) -> DoubleVector"""
        return _QuantLib.ZeroInflationCurve_data(self)

    def rates(self):
        r"""rates(ZeroInflationCurve self) -> DoubleVector"""
        return _QuantLib.ZeroInflationCurve_rates(self)

    def nodes(self):
        r"""nodes(ZeroInflationCurve self) -> NodeVector"""
        return _QuantLib.ZeroInflationCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationCurve

# Register ZeroInflationCurve in _QuantLib:
_QuantLib.ZeroInflationCurve_swigregister(ZeroInflationCurve)
class YoYInflationCurve(YoYInflationTermStructure):
    r"""Proxy of C++ InterpolatedYoYInflationCurve< Linear > class."""

    thisown = 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):
        r"""__init__(YoYInflationCurve self, Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, bool indexIsInterpolated, DateVector dates, DoubleVector rates, Linear interpolator=Linear()) -> YoYInflationCurve"""
        _QuantLib.YoYInflationCurve_swiginit(self, _QuantLib.new_YoYInflationCurve(*args, **kwargs))

    def dates(self):
        r"""dates(YoYInflationCurve self) -> DateVector"""
        return _QuantLib.YoYInflationCurve_dates(self)

    def times(self):
        r"""times(YoYInflationCurve self) -> DoubleVector"""
        return _QuantLib.YoYInflationCurve_times(self)

    def data(self):
        r"""data(YoYInflationCurve self) -> DoubleVector"""
        return _QuantLib.YoYInflationCurve_data(self)

    def rates(self):
        r"""rates(YoYInflationCurve self) -> DoubleVector"""
        return _QuantLib.YoYInflationCurve_rates(self)

    def nodes(self):
        r"""nodes(YoYInflationCurve self) -> NodeVector"""
        return _QuantLib.YoYInflationCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationCurve

# Register YoYInflationCurve in _QuantLib:
_QuantLib.YoYInflationCurve_swigregister(YoYInflationCurve)
class YoYCapFloorTermPriceSurface(InflationTermStructure):
    r"""Proxy of C++ YoYCapFloorTermPriceSurface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def atmYoYSwapTimeRates(self):
        r"""atmYoYSwapTimeRates(YoYCapFloorTermPriceSurface self) -> PairDoubleVector"""
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates(self)

    def atmYoYSwapDateRates(self):
        r"""atmYoYSwapDateRates(YoYCapFloorTermPriceSurface self) -> std::pair< std::vector< Date,std::allocator< Date > >,std::vector< Rate,std::allocator< Rate > > >"""
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYSwapDateRates(self)

    def YoYTS(self):
        r"""YoYTS(YoYCapFloorTermPriceSurface self) -> ext::shared_ptr< YoYInflationTermStructure >"""
        return _QuantLib.YoYCapFloorTermPriceSurface_YoYTS(self)

    def yoyIndex(self):
        r"""yoyIndex(YoYCapFloorTermPriceSurface self) -> ext::shared_ptr< YoYInflationIndex >"""
        return _QuantLib.YoYCapFloorTermPriceSurface_yoyIndex(self)

    def businessDayConvention(self):
        r"""businessDayConvention(YoYCapFloorTermPriceSurface self) -> BusinessDayConvention"""
        return _QuantLib.YoYCapFloorTermPriceSurface_businessDayConvention(self)

    def fixingDays(self):
        r"""fixingDays(YoYCapFloorTermPriceSurface self) -> Natural"""
        return _QuantLib.YoYCapFloorTermPriceSurface_fixingDays(self)

    def price(self, *args):
        r"""
        price(YoYCapFloorTermPriceSurface self, Date d, Rate k) -> Real
        price(YoYCapFloorTermPriceSurface self, Period d, Rate k) -> Real
        """
        return _QuantLib.YoYCapFloorTermPriceSurface_price(self, *args)

    def capPrice(self, *args):
        r"""
        capPrice(YoYCapFloorTermPriceSurface self, Date d, Rate k) -> Real
        capPrice(YoYCapFloorTermPriceSurface self, Period d, Rate k) -> Real
        """
        return _QuantLib.YoYCapFloorTermPriceSurface_capPrice(self, *args)

    def floorPrice(self, *args):
        r"""
        floorPrice(YoYCapFloorTermPriceSurface self, Date d, Rate k) -> Real
        floorPrice(YoYCapFloorTermPriceSurface self, Period d, Rate k) -> Real
        """
        return _QuantLib.YoYCapFloorTermPriceSurface_floorPrice(self, *args)

    def atmYoYSwapRate(self, *args):
        r"""
        atmYoYSwapRate(YoYCapFloorTermPriceSurface self, Date d, bool extrapolate=True) -> Rate
        atmYoYSwapRate(YoYCapFloorTermPriceSurface self, Period d, bool extrapolate=True) -> Rate
        """
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYSwapRate(self, *args)

    def atmYoYRate(self, *args):
        r"""
        atmYoYRate(YoYCapFloorTermPriceSurface self, Date d, Period obsLag=Period(-1,Days), bool extrapolate=True) -> Rate
        atmYoYRate(YoYCapFloorTermPriceSurface self, Period d, Period obsLag=Period(-1,Days), bool extrapolate=True) -> Rate
        """
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYRate(self, *args)

    def strikes(self):
        r"""strikes(YoYCapFloorTermPriceSurface self) -> DoubleVector"""
        return _QuantLib.YoYCapFloorTermPriceSurface_strikes(self)

    def capStrikes(self):
        r"""capStrikes(YoYCapFloorTermPriceSurface self) -> DoubleVector"""
        return _QuantLib.YoYCapFloorTermPriceSurface_capStrikes(self)

    def floorStrikes(self):
        r"""floorStrikes(YoYCapFloorTermPriceSurface self) -> DoubleVector"""
        return _QuantLib.YoYCapFloorTermPriceSurface_floorStrikes(self)

    def maturities(self):
        r"""maturities(YoYCapFloorTermPriceSurface self) -> PeriodVector"""
        return _QuantLib.YoYCapFloorTermPriceSurface_maturities(self)

    def minStrike(self):
        r"""minStrike(YoYCapFloorTermPriceSurface self) -> Rate"""
        return _QuantLib.YoYCapFloorTermPriceSurface_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(YoYCapFloorTermPriceSurface self) -> Rate"""
        return _QuantLib.YoYCapFloorTermPriceSurface_maxStrike(self)

    def minMaturity(self):
        r"""minMaturity(YoYCapFloorTermPriceSurface self) -> Date"""
        return _QuantLib.YoYCapFloorTermPriceSurface_minMaturity(self)

    def maxMaturity(self):
        r"""maxMaturity(YoYCapFloorTermPriceSurface self) -> Date"""
        return _QuantLib.YoYCapFloorTermPriceSurface_maxMaturity(self)

    def yoyOptionDateFromTenor(self, p):
        r"""yoyOptionDateFromTenor(YoYCapFloorTermPriceSurface self, Period p) -> Date"""
        return _QuantLib.YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor(self, p)
    __swig_destroy__ = _QuantLib.delete_YoYCapFloorTermPriceSurface

# Register YoYCapFloorTermPriceSurface in _QuantLib:
_QuantLib.YoYCapFloorTermPriceSurface_swigregister(YoYCapFloorTermPriceSurface)
class YoYInflationCapFloorTermPriceSurface(YoYCapFloorTermPriceSurface):
    r"""Proxy of C++ YoYInflationCapFloorTermPriceSurface class."""

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

    def __init__(self, *args):
        r"""__init__(YoYInflationCapFloorTermPriceSurface self, Natural fixingDays, Period yyLag, ext::shared_ptr< YoYInflationIndex > const & yii, Rate baseRate, YieldTermStructureHandle nominal, DayCounter dc, Calendar cal, BusinessDayConvention const & bdc, DoubleVector cStrikes, DoubleVector fStrikes, PeriodVector cfMaturities, Matrix cPrice, Matrix fPrice, Bicubic interpolator2d=Bicubic(), Cubic interpolator1d=Cubic()) -> YoYInflationCapFloorTermPriceSurface"""
        _QuantLib.YoYInflationCapFloorTermPriceSurface_swiginit(self, _QuantLib.new_YoYInflationCapFloorTermPriceSurface(*args))
    __swig_destroy__ = _QuantLib.delete_YoYInflationCapFloorTermPriceSurface

# Register YoYInflationCapFloorTermPriceSurface in _QuantLib:
_QuantLib.YoYInflationCapFloorTermPriceSurface_swigregister(YoYInflationCapFloorTermPriceSurface)
class YoYInflationBlackCapFloorEngine(PricingEngine):
    r"""Proxy of C++ YoYInflationBlackCapFloorEngine class."""

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

    def __init__(self, arg2, vol, nominalTermStructure):
        r"""__init__(YoYInflationBlackCapFloorEngine self, ext::shared_ptr< YoYInflationIndex > const & arg2, YoYOptionletVolatilitySurfaceHandle vol, YieldTermStructureHandle nominalTermStructure) -> YoYInflationBlackCapFloorEngine"""
        _QuantLib.YoYInflationBlackCapFloorEngine_swiginit(self, _QuantLib.new_YoYInflationBlackCapFloorEngine(arg2, vol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_YoYInflationBlackCapFloorEngine

# Register YoYInflationBlackCapFloorEngine in _QuantLib:
_QuantLib.YoYInflationBlackCapFloorEngine_swigregister(YoYInflationBlackCapFloorEngine)
class YoYInflationUnitDisplacedBlackCapFloorEngine(PricingEngine):
    r"""Proxy of C++ YoYInflationUnitDisplacedBlackCapFloorEngine class."""

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

    def __init__(self, arg2, vol, nominalTermStructure):
        r"""__init__(YoYInflationUnitDisplacedBlackCapFloorEngine self, ext::shared_ptr< YoYInflationIndex > const & arg2, YoYOptionletVolatilitySurfaceHandle vol, YieldTermStructureHandle nominalTermStructure) -> YoYInflationUnitDisplacedBlackCapFloorEngine"""
        _QuantLib.YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit(self, _QuantLib.new_YoYInflationUnitDisplacedBlackCapFloorEngine(arg2, vol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_YoYInflationUnitDisplacedBlackCapFloorEngine

# Register YoYInflationUnitDisplacedBlackCapFloorEngine in _QuantLib:
_QuantLib.YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister(YoYInflationUnitDisplacedBlackCapFloorEngine)
class YoYInflationBachelierCapFloorEngine(PricingEngine):
    r"""Proxy of C++ YoYInflationBachelierCapFloorEngine class."""

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

    def __init__(self, arg2, vol, nominalTermStructure):
        r"""__init__(YoYInflationBachelierCapFloorEngine self, ext::shared_ptr< YoYInflationIndex > const & arg2, YoYOptionletVolatilitySurfaceHandle vol, YieldTermStructureHandle nominalTermStructure) -> YoYInflationBachelierCapFloorEngine"""
        _QuantLib.YoYInflationBachelierCapFloorEngine_swiginit(self, _QuantLib.new_YoYInflationBachelierCapFloorEngine(arg2, vol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_YoYInflationBachelierCapFloorEngine

# Register YoYInflationBachelierCapFloorEngine in _QuantLib:
_QuantLib.YoYInflationBachelierCapFloorEngine_swigregister(YoYInflationBachelierCapFloorEngine)
class YoYOptionletHelper(YoYOptionHelper):
    r"""Proxy of C++ YoYOptionletHelper class."""

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

    def __init__(self, price, notional, capFloorType, lag, yoyDayCounter, paymentCalendar, fixingDays, index, strike, n, pricer):
        r"""__init__(YoYOptionletHelper self, QuoteHandle price, Real notional, YoYInflationCapFloor::Type capFloorType, Period lag, DayCounter yoyDayCounter, Calendar paymentCalendar, Natural fixingDays, ext::shared_ptr< YoYInflationIndex > const & index, Rate strike, Size n, ext::shared_ptr< PricingEngine > const & pricer) -> YoYOptionletHelper"""
        _QuantLib.YoYOptionletHelper_swiginit(self, _QuantLib.new_YoYOptionletHelper(price, notional, capFloorType, lag, yoyDayCounter, paymentCalendar, fixingDays, index, strike, n, pricer))
    __swig_destroy__ = _QuantLib.delete_YoYOptionletHelper

# Register YoYOptionletHelper in _QuantLib:
_QuantLib.YoYOptionletHelper_swigregister(YoYOptionletHelper)
class YoYOptionletStripper(object):
    r"""Proxy of C++ YoYOptionletStripper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def initialize(self, surf, pricer, slope):
        r"""initialize(YoYOptionletStripper self, ext::shared_ptr< YoYCapFloorTermPriceSurface > const & surf, ext::shared_ptr< PricingEngine > const & pricer, Real slope)"""
        return _QuantLib.YoYOptionletStripper_initialize(self, surf, pricer, slope)

    def maxStrike(self):
        r"""maxStrike(YoYOptionletStripper self) -> Rate"""
        return _QuantLib.YoYOptionletStripper_maxStrike(self)

    def strikes(self):
        r"""strikes(YoYOptionletStripper self) -> DoubleVector"""
        return _QuantLib.YoYOptionletStripper_strikes(self)

    def slice(self, d):
        r"""slice(YoYOptionletStripper self, Date d) -> PairDoubleVector"""
        return _QuantLib.YoYOptionletStripper_slice(self, d)
    __swig_destroy__ = _QuantLib.delete_YoYOptionletStripper

# Register YoYOptionletStripper in _QuantLib:
_QuantLib.YoYOptionletStripper_swigregister(YoYOptionletStripper)
class InterpolatedYoYInflationOptionletStripper(YoYOptionletStripper):
    r"""Proxy of C++ InterpolatedYoYOptionletStripper< Linear > class."""

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

    def __init__(self):
        r"""__init__(InterpolatedYoYInflationOptionletStripper self) -> InterpolatedYoYInflationOptionletStripper"""
        _QuantLib.InterpolatedYoYInflationOptionletStripper_swiginit(self, _QuantLib.new_InterpolatedYoYInflationOptionletStripper())
    __swig_destroy__ = _QuantLib.delete_InterpolatedYoYInflationOptionletStripper

# Register InterpolatedYoYInflationOptionletStripper in _QuantLib:
_QuantLib.InterpolatedYoYInflationOptionletStripper_swigregister(InterpolatedYoYInflationOptionletStripper)
class InterpolatedYoYInflationOptionletVolatilityCurve(YoYOptionletVolatilitySurface):
    r"""Proxy of C++ InterpolatedYoYOptionletVolatilityCurve< Linear > class."""

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

    def __init__(self, *args):
        r"""__init__(InterpolatedYoYInflationOptionletVolatilityCurve self, Natural settlementDays, Calendar arg3, BusinessDayConvention bdc, DayCounter dc, Period lag, Frequency frequency, bool indexIsInterpolated, DateVector d, DoubleVector v, Rate minStrike, Rate maxStrike, Linear i=Linear()) -> InterpolatedYoYInflationOptionletVolatilityCurve"""
        _QuantLib.InterpolatedYoYInflationOptionletVolatilityCurve_swiginit(self, _QuantLib.new_InterpolatedYoYInflationOptionletVolatilityCurve(*args))
    __swig_destroy__ = _QuantLib.delete_InterpolatedYoYInflationOptionletVolatilityCurve

# Register InterpolatedYoYInflationOptionletVolatilityCurve in _QuantLib:
_QuantLib.InterpolatedYoYInflationOptionletVolatilityCurve_swigregister(InterpolatedYoYInflationOptionletVolatilityCurve)
class KInterpolatedYoYInflationOptionletVolatilitySurface(YoYOptionletVolatilitySurface):
    r"""Proxy of C++ KInterpolatedYoYOptionletVolatilitySurface< Linear > class."""

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

    def __init__(self, *args):
        r"""__init__(KInterpolatedYoYInflationOptionletVolatilitySurface self, Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, DayCounter dc, Period lag, ext::shared_ptr< YoYCapFloorTermPriceSurface > const & capFloorPrices, ext::shared_ptr< PricingEngine > const & pricer, ext::shared_ptr< YoYOptionletStripper > const & yoyOptionletStripper, Real slope, Linear interpolator=Linear()) -> KInterpolatedYoYInflationOptionletVolatilitySurface"""
        _QuantLib.KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit(self, _QuantLib.new_KInterpolatedYoYInflationOptionletVolatilitySurface(*args))

    def Dslice(self, d):
        r"""Dslice(KInterpolatedYoYInflationOptionletVolatilitySurface self, Date d) -> PairDoubleVector"""
        return _QuantLib.KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice(self, d)
    __swig_destroy__ = _QuantLib.delete_KInterpolatedYoYInflationOptionletVolatilitySurface

# Register KInterpolatedYoYInflationOptionletVolatilitySurface in _QuantLib:
_QuantLib.KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister(KInterpolatedYoYInflationOptionletVolatilitySurface)
class ShortRateModel(CalibratedModel):
    r"""Proxy of C++ ShortRateModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register ShortRateModel in _QuantLib:
_QuantLib.ShortRateModel_swigregister(ShortRateModel)
class ShortRateModelHandle(object):
    r"""Proxy of C++ Handle< ShortRateModel > class."""

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

    def __init__(self, *args):
        r"""__init__(ShortRateModelHandle self, ext::shared_ptr< ShortRateModel > const & arg2=ext::shared_ptr()) -> ShortRateModelHandle"""
        _QuantLib.ShortRateModelHandle_swiginit(self, _QuantLib.new_ShortRateModelHandle(*args))

    def __deref__(self):
        r"""__deref__(ShortRateModelHandle self) -> ext::shared_ptr< ShortRateModel >"""
        return _QuantLib.ShortRateModelHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(ShortRateModelHandle self) -> ext::shared_ptr< ShortRateModel >"""
        return _QuantLib.ShortRateModelHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(ShortRateModelHandle self) -> bool"""
        return _QuantLib.ShortRateModelHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ShortRateModelHandle self) -> bool"""
        return _QuantLib.ShortRateModelHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(ShortRateModelHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.ShortRateModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_ShortRateModelHandle

    def params(self):
        r"""params(ShortRateModelHandle self) -> Array"""
        return _QuantLib.ShortRateModelHandle_params(self)

    def calibrate(self, *args):
        r"""calibrate(ShortRateModelHandle self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"""
        return _QuantLib.ShortRateModelHandle_calibrate(self, *args)

    def setParams(self, params):
        r"""setParams(ShortRateModelHandle self, Array params)"""
        return _QuantLib.ShortRateModelHandle_setParams(self, params)

    def value(self, params, arg3):
        r"""value(ShortRateModelHandle self, Array params, CalibrationHelperVector arg3) -> Real"""
        return _QuantLib.ShortRateModelHandle_value(self, params, arg3)

    def constraint(self):
        r"""constraint(ShortRateModelHandle self) -> ext::shared_ptr< Constraint > const &"""
        return _QuantLib.ShortRateModelHandle_constraint(self)

    def endCriteria(self):
        r"""endCriteria(ShortRateModelHandle self) -> EndCriteria::Type"""
        return _QuantLib.ShortRateModelHandle_endCriteria(self)

    def problemValues(self):
        r"""problemValues(ShortRateModelHandle self) -> Array"""
        return _QuantLib.ShortRateModelHandle_problemValues(self)

    def functionEvaluation(self):
        r"""functionEvaluation(ShortRateModelHandle self) -> Integer"""
        return _QuantLib.ShortRateModelHandle_functionEvaluation(self)

# Register ShortRateModelHandle in _QuantLib:
_QuantLib.ShortRateModelHandle_swigregister(ShortRateModelHandle)
class RelinkableShortRateModelHandle(ShortRateModelHandle):
    r"""Proxy of C++ RelinkableHandle< ShortRateModel > class."""

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

    def __init__(self, *args):
        r"""__init__(RelinkableShortRateModelHandle self, ext::shared_ptr< ShortRateModel > const & arg2=ext::shared_ptr()) -> RelinkableShortRateModelHandle"""
        _QuantLib.RelinkableShortRateModelHandle_swiginit(self, _QuantLib.new_RelinkableShortRateModelHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableShortRateModelHandle self, ext::shared_ptr< ShortRateModel > const & arg2)"""
        return _QuantLib.RelinkableShortRateModelHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableShortRateModelHandle self)"""
        return _QuantLib.RelinkableShortRateModelHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableShortRateModelHandle

# Register RelinkableShortRateModelHandle in _QuantLib:
_QuantLib.RelinkableShortRateModelHandle_swigregister(RelinkableShortRateModelHandle)
class OneFactorAffineModel(ShortRateModel):
    r"""Proxy of C++ OneFactorAffineModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def discountBond(self, *args):
        r"""
        discountBond(OneFactorAffineModel self, Time now, Time maturity, Array factors) -> Real
        discountBond(OneFactorAffineModel self, Time now, Time maturity, Rate rate) -> Real
        """
        return _QuantLib.OneFactorAffineModel_discountBond(self, *args)

    def discount(self, t):
        r"""discount(OneFactorAffineModel self, Time t) -> DiscountFactor"""
        return _QuantLib.OneFactorAffineModel_discount(self, t)
    __swig_destroy__ = _QuantLib.delete_OneFactorAffineModel

# Register OneFactorAffineModel in _QuantLib:
_QuantLib.OneFactorAffineModel_swigregister(OneFactorAffineModel)
class Vasicek(OneFactorAffineModel):
    r"""Proxy of C++ Vasicek class."""

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

    def __init__(self, r0=0.05, a=0.1, b=0.05, sigma=0.01, lambda_parameter=0.0):
        r"""__init__(Vasicek self, Rate r0=0.05, Real a=0.1, Real b=0.05, Real sigma=0.01, Real lambda_parameter=0.0) -> Vasicek"""
        _QuantLib.Vasicek_swiginit(self, _QuantLib.new_Vasicek(r0, a, b, sigma, lambda_parameter))
    __swig_destroy__ = _QuantLib.delete_Vasicek

# Register Vasicek in _QuantLib:
_QuantLib.Vasicek_swigregister(Vasicek)
class HullWhite(Vasicek):
    r"""Proxy of C++ HullWhite class."""

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

    def __init__(self, termStructure, a=0.1, sigma=0.01):
        r"""__init__(HullWhite self, YieldTermStructureHandle termStructure, Real a=0.1, Real sigma=0.01) -> HullWhite"""
        _QuantLib.HullWhite_swiginit(self, _QuantLib.new_HullWhite(termStructure, a, sigma))

    @staticmethod
    def convexityBias(futurePrice, t, T, sigma, a):
        r"""convexityBias(Real futurePrice, Time t, Time T, Real sigma, Real a) -> Rate"""
        return _QuantLib.HullWhite_convexityBias(futurePrice, t, T, sigma, a)

    def termStructure(self):
        r"""termStructure(HullWhite self) -> YieldTermStructureHandle"""
        return _QuantLib.HullWhite_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_HullWhite

# Register HullWhite in _QuantLib:
_QuantLib.HullWhite_swigregister(HullWhite)
class BlackKarasinski(ShortRateModel):
    r"""Proxy of C++ BlackKarasinski class."""

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

    def __init__(self, termStructure, a=0.1, sigma=0.1):
        r"""__init__(BlackKarasinski self, YieldTermStructureHandle termStructure, Real a=0.1, Real sigma=0.1) -> BlackKarasinski"""
        _QuantLib.BlackKarasinski_swiginit(self, _QuantLib.new_BlackKarasinski(termStructure, a, sigma))

    def termStructure(self):
        r"""termStructure(BlackKarasinski self) -> YieldTermStructureHandle"""
        return _QuantLib.BlackKarasinski_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_BlackKarasinski

# Register BlackKarasinski in _QuantLib:
_QuantLib.BlackKarasinski_swigregister(BlackKarasinski)
class CoxIngersollRoss(ShortRateModel):
    r"""Proxy of C++ CoxIngersollRoss class."""

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

    def __init__(self, r0=0.01, theta=0.1, k=0.1, sigma=0.1):
        r"""__init__(CoxIngersollRoss self, Rate r0=0.01, Real theta=0.1, Real k=0.1, Real sigma=0.1) -> CoxIngersollRoss"""
        _QuantLib.CoxIngersollRoss_swiginit(self, _QuantLib.new_CoxIngersollRoss(r0, theta, k, sigma))

    def discount(self, t):
        r"""discount(CoxIngersollRoss self, Time t) -> DiscountFactor"""
        return _QuantLib.CoxIngersollRoss_discount(self, t)
    __swig_destroy__ = _QuantLib.delete_CoxIngersollRoss

# Register CoxIngersollRoss in _QuantLib:
_QuantLib.CoxIngersollRoss_swigregister(CoxIngersollRoss)
class ExtendedCoxIngersollRoss(ShortRateModel):
    r"""Proxy of C++ ExtendedCoxIngersollRoss class."""

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

    def __init__(self, termStructure, theta=0.1, k=0.1, sigma=0.1, x0=0.05):
        r"""__init__(ExtendedCoxIngersollRoss self, YieldTermStructureHandle termStructure, Real theta=0.1, Real k=0.1, Real sigma=0.1, Real x0=0.05) -> ExtendedCoxIngersollRoss"""
        _QuantLib.ExtendedCoxIngersollRoss_swiginit(self, _QuantLib.new_ExtendedCoxIngersollRoss(termStructure, theta, k, sigma, x0))

    def discount(self, t):
        r"""discount(ExtendedCoxIngersollRoss self, Time t) -> DiscountFactor"""
        return _QuantLib.ExtendedCoxIngersollRoss_discount(self, t)
    __swig_destroy__ = _QuantLib.delete_ExtendedCoxIngersollRoss

# Register ExtendedCoxIngersollRoss in _QuantLib:
_QuantLib.ExtendedCoxIngersollRoss_swigregister(ExtendedCoxIngersollRoss)
class G2(ShortRateModel):
    r"""Proxy of C++ G2 class."""

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

    def __init__(self, termStructure, a=0.1, sigma=0.01, b=0.1, eta=0.01, rho=-0.75):
        r"""__init__(G2 self, YieldTermStructureHandle termStructure, Real a=0.1, Real sigma=0.01, Real b=0.1, Real eta=0.01, Real rho=-0.75) -> G2"""
        _QuantLib.G2_swiginit(self, _QuantLib.new_G2(termStructure, a, sigma, b, eta, rho))

    def termStructure(self):
        r"""termStructure(G2 self) -> YieldTermStructureHandle"""
        return _QuantLib.G2_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_G2

# Register G2 in _QuantLib:
_QuantLib.G2_swigregister(G2)
class JamshidianSwaptionEngine(PricingEngine):
    r"""Proxy of C++ JamshidianSwaptionEngine class."""

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

    def __init__(self, *args):
        r"""__init__(JamshidianSwaptionEngine self, ext::shared_ptr< OneFactorAffineModel > const & model, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> JamshidianSwaptionEngine"""
        _QuantLib.JamshidianSwaptionEngine_swiginit(self, _QuantLib.new_JamshidianSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_JamshidianSwaptionEngine

# Register JamshidianSwaptionEngine in _QuantLib:
_QuantLib.JamshidianSwaptionEngine_swigregister(JamshidianSwaptionEngine)
class TreeSwaptionEngine(PricingEngine):
    r"""Proxy of C++ TreeSwaptionEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(TreeSwaptionEngine self, ext::shared_ptr< ShortRateModel > const & model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeSwaptionEngine
        __init__(TreeSwaptionEngine self, ext::shared_ptr< ShortRateModel > const & model, TimeGrid grid, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeSwaptionEngine
        __init__(TreeSwaptionEngine self, ShortRateModelHandle model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeSwaptionEngine
        """
        _QuantLib.TreeSwaptionEngine_swiginit(self, _QuantLib.new_TreeSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_TreeSwaptionEngine

# Register TreeSwaptionEngine in _QuantLib:
_QuantLib.TreeSwaptionEngine_swigregister(TreeSwaptionEngine)
class AnalyticCapFloorEngine(PricingEngine):
    r"""Proxy of C++ AnalyticCapFloorEngine class."""

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

    def __init__(self, *args):
        r"""__init__(AnalyticCapFloorEngine self, ext::shared_ptr< OneFactorAffineModel > const & model, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> AnalyticCapFloorEngine"""
        _QuantLib.AnalyticCapFloorEngine_swiginit(self, _QuantLib.new_AnalyticCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticCapFloorEngine

# Register AnalyticCapFloorEngine in _QuantLib:
_QuantLib.AnalyticCapFloorEngine_swigregister(AnalyticCapFloorEngine)
class TreeCapFloorEngine(PricingEngine):
    r"""Proxy of C++ TreeCapFloorEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(TreeCapFloorEngine self, ext::shared_ptr< ShortRateModel > const & model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeCapFloorEngine
        __init__(TreeCapFloorEngine self, ext::shared_ptr< ShortRateModel > const & model, TimeGrid grid, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeCapFloorEngine
        """
        _QuantLib.TreeCapFloorEngine_swiginit(self, _QuantLib.new_TreeCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_TreeCapFloorEngine

# Register TreeCapFloorEngine in _QuantLib:
_QuantLib.TreeCapFloorEngine_swigregister(TreeCapFloorEngine)
class G2SwaptionEngine(PricingEngine):
    r"""Proxy of C++ G2SwaptionEngine class."""

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

    def __init__(self, model, range, intervals):
        r"""__init__(G2SwaptionEngine self, ext::shared_ptr< G2 > const & model, Real range, Size intervals) -> G2SwaptionEngine"""
        _QuantLib.G2SwaptionEngine_swiginit(self, _QuantLib.new_G2SwaptionEngine(model, range, intervals))
    __swig_destroy__ = _QuantLib.delete_G2SwaptionEngine

# Register G2SwaptionEngine in _QuantLib:
_QuantLib.G2SwaptionEngine_swigregister(G2SwaptionEngine)
class FdG2SwaptionEngine(PricingEngine):
    r"""Proxy of C++ FdG2SwaptionEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdG2SwaptionEngine self, ext::shared_ptr< G2 > const & model, Size tGrid=100, Size xGrid=50, Size yGrid=50, Size dampingSteps=0, Real invEps=1e-5, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdG2SwaptionEngine"""
        _QuantLib.FdG2SwaptionEngine_swiginit(self, _QuantLib.new_FdG2SwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdG2SwaptionEngine

# Register FdG2SwaptionEngine in _QuantLib:
_QuantLib.FdG2SwaptionEngine_swigregister(FdG2SwaptionEngine)
class FdHullWhiteSwaptionEngine(PricingEngine):
    r"""Proxy of C++ FdHullWhiteSwaptionEngine class."""

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

    def __init__(self, *args):
        r"""__init__(FdHullWhiteSwaptionEngine self, ext::shared_ptr< HullWhite > const & model, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, Real invEps=1e-5, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas()) -> FdHullWhiteSwaptionEngine"""
        _QuantLib.FdHullWhiteSwaptionEngine_swiginit(self, _QuantLib.new_FdHullWhiteSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHullWhiteSwaptionEngine

# Register FdHullWhiteSwaptionEngine in _QuantLib:
_QuantLib.FdHullWhiteSwaptionEngine_swigregister(FdHullWhiteSwaptionEngine)
class AnalyticBSMHullWhiteEngine(PricingEngine):
    r"""Proxy of C++ AnalyticBSMHullWhiteEngine class."""

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

    def __init__(self, equityShortRateCorrelation, arg3, arg4):
        r"""__init__(AnalyticBSMHullWhiteEngine self, Real equityShortRateCorrelation, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg3, ext::shared_ptr< HullWhite > const & arg4) -> AnalyticBSMHullWhiteEngine"""
        _QuantLib.AnalyticBSMHullWhiteEngine_swiginit(self, _QuantLib.new_AnalyticBSMHullWhiteEngine(equityShortRateCorrelation, arg3, arg4))
    __swig_destroy__ = _QuantLib.delete_AnalyticBSMHullWhiteEngine

# Register AnalyticBSMHullWhiteEngine in _QuantLib:
_QuantLib.AnalyticBSMHullWhiteEngine_swigregister(AnalyticBSMHullWhiteEngine)
class BondPrice(object):
    r"""Proxy of C++ BondPrice class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Dirty = _QuantLib.BondPrice_Dirty
    
    Clean = _QuantLib.BondPrice_Clean
    

    def __init__(self, amount, type):
        r"""__init__(BondPrice self, Real amount, BondPrice::Type type) -> BondPrice"""
        _QuantLib.BondPrice_swiginit(self, _QuantLib.new_BondPrice(amount, type))

    def amount(self):
        r"""amount(BondPrice self) -> Real"""
        return _QuantLib.BondPrice_amount(self)

    def type(self):
        r"""type(BondPrice self) -> BondPrice::Type"""
        return _QuantLib.BondPrice_type(self)
    __swig_destroy__ = _QuantLib.delete_BondPrice

# Register BondPrice in _QuantLib:
_QuantLib.BondPrice_swigregister(BondPrice)
class Bond(Instrument):
    r"""Proxy of C++ Bond class."""

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

    def __init__(self, *args):
        r"""
        __init__(Bond self, Natural settlementDays, Calendar calendar, Real faceAmount, Date maturityDate, Date issueDate=Date(), Leg cashflows=Leg()) -> Bond
        __init__(Bond self, Natural settlementDays, Calendar calendar, Date issueDate=Date(), Leg coupons=Leg()) -> Bond
        """
        _QuantLib.Bond_swiginit(self, _QuantLib.new_Bond(*args))

    def nextCouponRate(self, *args):
        r"""nextCouponRate(Bond self, Date d=Date()) -> Rate"""
        return _QuantLib.Bond_nextCouponRate(self, *args)

    def previousCouponRate(self, *args):
        r"""previousCouponRate(Bond self, Date d=Date()) -> Rate"""
        return _QuantLib.Bond_previousCouponRate(self, *args)

    def settlementDays(self):
        r"""settlementDays(Bond self) -> Natural"""
        return _QuantLib.Bond_settlementDays(self)

    def settlementDate(self, *args):
        r"""settlementDate(Bond self, Date d=Date()) -> Date"""
        return _QuantLib.Bond_settlementDate(self, *args)

    def startDate(self):
        r"""startDate(Bond self) -> Date"""
        return _QuantLib.Bond_startDate(self)

    def maturityDate(self):
        r"""maturityDate(Bond self) -> Date"""
        return _QuantLib.Bond_maturityDate(self)

    def issueDate(self):
        r"""issueDate(Bond self) -> Date"""
        return _QuantLib.Bond_issueDate(self)

    def cashflows(self):
        r"""cashflows(Bond self) -> Leg"""
        return _QuantLib.Bond_cashflows(self)

    def redemptions(self):
        r"""redemptions(Bond self) -> Leg"""
        return _QuantLib.Bond_redemptions(self)

    def redemption(self):
        r"""redemption(Bond self) -> ext::shared_ptr< CashFlow >"""
        return _QuantLib.Bond_redemption(self)

    def calendar(self):
        r"""calendar(Bond self) -> Calendar"""
        return _QuantLib.Bond_calendar(self)

    def notionals(self):
        r"""notionals(Bond self) -> DoubleVector"""
        return _QuantLib.Bond_notionals(self)

    def notional(self, *args):
        r"""notional(Bond self, Date d=Date()) -> Real"""
        return _QuantLib.Bond_notional(self, *args)

    def cleanPrice(self, *args):
        r"""
        cleanPrice(Bond self) -> Real
        cleanPrice(Bond self, Rate _yield, DayCounter dc, Compounding compounding, Frequency frequency, Date settlement=Date()) -> Real
        """
        return _QuantLib.Bond_cleanPrice(self, *args)

    def dirtyPrice(self, *args):
        r"""
        dirtyPrice(Bond self) -> Real
        dirtyPrice(Bond self, Rate _yield, DayCounter dc, Compounding compounding, Frequency frequency, Date settlement=Date()) -> Real
        """
        return _QuantLib.Bond_dirtyPrice(self, *args)

    def bondYield(self, *args):
        r"""
        bondYield(Bond self, DayCounter dc, Compounding compounding, Frequency freq, Real accuracy=1.0e-8, Size maxEvaluations=100) -> Real
        bondYield(Bond self, Real cleanPrice, DayCounter dc, Compounding compounding, Frequency freq, Date settlement=Date(), Real accuracy=1.0e-8, Size maxEvaluations=100) -> Real
        """
        return _QuantLib.Bond_bondYield(self, *args)

    def accruedAmount(self, *args):
        r"""accruedAmount(Bond self, Date settlement=Date()) -> Real"""
        return _QuantLib.Bond_accruedAmount(self, *args)

    def settlementValue(self, *args):
        r"""
        settlementValue(Bond self) -> Real
        settlementValue(Bond self, Real cleanPrice) -> Real
        """
        return _QuantLib.Bond_settlementValue(self, *args)
    __swig_destroy__ = _QuantLib.delete_Bond

# Register Bond in _QuantLib:
_QuantLib.Bond_swigregister(Bond)

def cleanPriceFromZSpread(*args):
    r"""cleanPriceFromZSpread(Bond bond, ext::shared_ptr< YieldTermStructure > const & discountCurve, Spread zSpread, DayCounter dc, Compounding compounding, Frequency freq, Date settlementDate=Date()) -> Real"""
    return _QuantLib.cleanPriceFromZSpread(*args)

def sinkingSchedule(startDate, bondLength, frequency, paymentCalendar):
    r"""sinkingSchedule(Date startDate, Period bondLength, Frequency const & frequency, Calendar paymentCalendar) -> Schedule"""
    return _QuantLib.sinkingSchedule(startDate, bondLength, frequency, paymentCalendar)

def sinkingNotionals(bondLength, frequency, couponRate, initialNotional):
    r"""sinkingNotionals(Period bondLength, Frequency const & frequency, Rate couponRate, Real initialNotional) -> DoubleVector"""
    return _QuantLib.sinkingNotionals(bondLength, frequency, couponRate, initialNotional)
class ZeroCouponBond(Bond):
    r"""Proxy of C++ ZeroCouponBond class."""

    thisown = 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):
        r"""__init__(ZeroCouponBond self, Natural settlementDays, Calendar calendar, Real faceAmount, Date maturityDate, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date()) -> ZeroCouponBond"""
        _QuantLib.ZeroCouponBond_swiginit(self, _QuantLib.new_ZeroCouponBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_ZeroCouponBond

# Register ZeroCouponBond in _QuantLib:
_QuantLib.ZeroCouponBond_swigregister(ZeroCouponBond)
class FixedRateBond(Bond):
    r"""Proxy of C++ FixedRateBond class."""

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

    def __init__(self, *args):
        r"""
        __init__(FixedRateBond self, Integer settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> FixedRateBond
        __init__(FixedRateBond self, Integer settlementDays, Real faceAmount, Schedule schedule, InterestRateVector coupons, BusinessDayConvention paymentConvention=Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> FixedRateBond
        __init__(FixedRateBond self, Integer settlementDays, Calendar couponCalendar, Real faceAmount, Date startDate, Date maturityDate, Period tenor, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention accrualConvention=QuantLib::Following, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date(), Date stubDate=Date(), DateGeneration::Rule rule=QuantLib::DateGeneration::Backward, bool endOfMonth=False, Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> FixedRateBond
        """
        _QuantLib.FixedRateBond_swiginit(self, _QuantLib.new_FixedRateBond(*args))

    @staticmethod
    def from_rates(*args, **kwargs):
        r"""from_rates(Integer settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> ext::shared_ptr< FixedRateBond >"""
        return _QuantLib.FixedRateBond_from_rates(*args, **kwargs)

    @staticmethod
    def from_interest_rates(*args, **kwargs):
        r"""from_interest_rates(Integer settlementDays, Real faceAmount, Schedule schedule, InterestRateVector coupons, BusinessDayConvention paymentConvention=Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> ext::shared_ptr< FixedRateBond >"""
        return _QuantLib.FixedRateBond_from_interest_rates(*args, **kwargs)

    @staticmethod
    def from_date_info(*args, **kwargs):
        r"""from_date_info(Integer settlementDays, Calendar couponCalendar, Real faceAmount, Date startDate, Date maturityDate, Period tenor, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention accrualConvention=QuantLib::Following, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date(), Date stubDate=Date(), DateGeneration::Rule rule=QuantLib::DateGeneration::Backward, bool endOfMonth=False, Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> ext::shared_ptr< FixedRateBond >"""
        return _QuantLib.FixedRateBond_from_date_info(*args, **kwargs)

    def frequency(self):
        r"""frequency(FixedRateBond self) -> Frequency"""
        return _QuantLib.FixedRateBond_frequency(self)

    def dayCounter(self):
        r"""dayCounter(FixedRateBond self) -> DayCounter"""
        return _QuantLib.FixedRateBond_dayCounter(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBond

# Register FixedRateBond in _QuantLib:
_QuantLib.FixedRateBond_swigregister(FixedRateBond)
class AmortizingFixedRateBond(Bond):
    r"""Proxy of C++ AmortizingFixedRateBond class."""

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

    def __init__(self, *args):
        r"""
        __init__(AmortizingFixedRateBond self, Integer settlementDays, DoubleVector notionals, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=QuantLib::Following, Date issueDate=Date(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> AmortizingFixedRateBond
        __init__(AmortizingFixedRateBond self, Integer settlementDays, Calendar paymentCalendar, Real faceAmount, Date startDate, Period bondTenor, Frequency const & sinkingFrequency, Real coupon, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=QuantLib::Following, Date issueDate=Date()) -> AmortizingFixedRateBond
        __init__(AmortizingFixedRateBond self, Integer settlementDays, DoubleVector notionals, Schedule schedule, InterestRateVector coupons, BusinessDayConvention paymentConvention=QuantLib::Following, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> AmortizingFixedRateBond
        """
        _QuantLib.AmortizingFixedRateBond_swiginit(self, _QuantLib.new_AmortizingFixedRateBond(*args))

    def frequency(self):
        r"""frequency(AmortizingFixedRateBond self) -> Frequency"""
        return _QuantLib.AmortizingFixedRateBond_frequency(self)

    def dayCounter(self):
        r"""dayCounter(AmortizingFixedRateBond self) -> DayCounter"""
        return _QuantLib.AmortizingFixedRateBond_dayCounter(self)
    __swig_destroy__ = _QuantLib.delete_AmortizingFixedRateBond

# Register AmortizingFixedRateBond in _QuantLib:
_QuantLib.AmortizingFixedRateBond_swigregister(AmortizingFixedRateBond)
class AmortizingFloatingRateBond(Bond):
    r"""Proxy of C++ AmortizingFloatingRateBond class."""

    thisown = 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):
        r"""__init__(AmortizingFloatingRateBond self, Size settlementDays, DoubleVector notional, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=Following, Size fixingDays=Null< Size >(), DoubleVector gearings=std::vector< Real >(1, 1.0), DoubleVector spreads=std::vector< Spread >(1, 0.0), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool inArrears=False, Date issueDate=Date(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> AmortizingFloatingRateBond"""
        _QuantLib.AmortizingFloatingRateBond_swiginit(self, _QuantLib.new_AmortizingFloatingRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_AmortizingFloatingRateBond

# Register AmortizingFloatingRateBond in _QuantLib:
_QuantLib.AmortizingFloatingRateBond_swigregister(AmortizingFloatingRateBond)
class FloatingRateBond(Bond):
    r"""Proxy of C++ FloatingRateBond class."""

    thisown = 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):
        r"""__init__(FloatingRateBond self, Size settlementDays, Real faceAmount, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=Following, Size fixingDays=Null< Size >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool inArrears=False, Real redemption=100.0, Date issueDate=Date(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> FloatingRateBond"""
        _QuantLib.FloatingRateBond_swiginit(self, _QuantLib.new_FloatingRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_FloatingRateBond

# Register FloatingRateBond in _QuantLib:
_QuantLib.FloatingRateBond_swigregister(FloatingRateBond)
class CmsRateBond(Bond):
    r"""Proxy of C++ CmsRateBond class."""

    thisown = 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):
        r"""__init__(CmsRateBond self, Size settlementDays, Real faceAmount, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention, Natural fixingDays, DoubleVector gearings, DoubleVector spreads, DoubleVector caps, DoubleVector floors, bool inArrears=False, Real redemption=100.0, Date issueDate=Date()) -> CmsRateBond"""
        _QuantLib.CmsRateBond_swiginit(self, _QuantLib.new_CmsRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CmsRateBond

# Register CmsRateBond in _QuantLib:
_QuantLib.CmsRateBond_swigregister(CmsRateBond)
class AmortizingCmsRateBond(Bond):
    r"""Proxy of C++ AmortizingCmsRateBond class."""

    thisown = 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):
        r"""__init__(AmortizingCmsRateBond self, Natural settlementDays, DoubleVector notionals, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=Following, Natural fixingDays=Null< Natural >(), DoubleVector gearings={ 1.0 }, DoubleVector spreads={ 0.0 }, DoubleVector caps={}, DoubleVector floors={}, bool inArrears=False, Date issueDate=Date()) -> AmortizingCmsRateBond"""
        _QuantLib.AmortizingCmsRateBond_swiginit(self, _QuantLib.new_AmortizingCmsRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_AmortizingCmsRateBond

# Register AmortizingCmsRateBond in _QuantLib:
_QuantLib.AmortizingCmsRateBond_swigregister(AmortizingCmsRateBond)
class DiscountingBondEngine(PricingEngine):
    r"""Proxy of C++ DiscountingBondEngine class."""

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

    def __init__(self, discountCurve):
        r"""__init__(DiscountingBondEngine self, YieldTermStructureHandle discountCurve) -> DiscountingBondEngine"""
        _QuantLib.DiscountingBondEngine_swiginit(self, _QuantLib.new_DiscountingBondEngine(discountCurve))
    __swig_destroy__ = _QuantLib.delete_DiscountingBondEngine

# Register DiscountingBondEngine in _QuantLib:
_QuantLib.DiscountingBondEngine_swigregister(DiscountingBondEngine)
class Callability(object):
    r"""Proxy of C++ Callability class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Call = _QuantLib.Callability_Call
    
    Put = _QuantLib.Callability_Put
    

    def __init__(self, price, type, date):
        r"""__init__(Callability self, BondPrice price, Callability::Type type, Date date) -> Callability"""
        _QuantLib.Callability_swiginit(self, _QuantLib.new_Callability(price, type, date))

    def price(self):
        r"""price(Callability self) -> BondPrice"""
        return _QuantLib.Callability_price(self)

    def type(self):
        r"""type(Callability self) -> Callability::Type"""
        return _QuantLib.Callability_type(self)

    def date(self):
        r"""date(Callability self) -> Date"""
        return _QuantLib.Callability_date(self)
    __swig_destroy__ = _QuantLib.delete_Callability

# Register Callability in _QuantLib:
_QuantLib.Callability_swigregister(Callability)
class SoftCallability(Callability):
    r"""Proxy of C++ SoftCallability class."""

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

    def __init__(self, price, date, trigger):
        r"""__init__(SoftCallability self, BondPrice price, Date date, Real trigger) -> SoftCallability"""
        _QuantLib.SoftCallability_swiginit(self, _QuantLib.new_SoftCallability(price, date, trigger))
    __swig_destroy__ = _QuantLib.delete_SoftCallability

# Register SoftCallability in _QuantLib:
_QuantLib.SoftCallability_swigregister(SoftCallability)
class CallabilitySchedule(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< Callability > > class."""

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

    def iterator(self):
        r"""iterator(CallabilitySchedule self) -> SwigPyIterator"""
        return _QuantLib.CallabilitySchedule_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(CallabilitySchedule self) -> bool"""
        return _QuantLib.CallabilitySchedule___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CallabilitySchedule self) -> bool"""
        return _QuantLib.CallabilitySchedule___bool__(self)

    def __len__(self):
        r"""__len__(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::size_type"""
        return _QuantLib.CallabilitySchedule___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j) -> CallabilitySchedule"""
        return _QuantLib.CallabilitySchedule___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j)
        __setslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j, CallabilitySchedule v)
        """
        return _QuantLib.CallabilitySchedule___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j)"""
        return _QuantLib.CallabilitySchedule___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i)
        __delitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.CallabilitySchedule___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice) -> CallabilitySchedule
        __getitem__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i) -> std::vector< ext::shared_ptr< Callability > >::value_type const &
        """
        return _QuantLib.CallabilitySchedule___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice, CallabilitySchedule v)
        __setitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::value_type const & x)
        """
        return _QuantLib.CallabilitySchedule___setitem__(self, *args)

    def pop(self):
        r"""pop(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::value_type"""
        return _QuantLib.CallabilitySchedule_pop(self)

    def append(self, x):
        r"""append(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::value_type const & x)"""
        return _QuantLib.CallabilitySchedule_append(self, x)

    def empty(self):
        r"""empty(CallabilitySchedule self) -> bool"""
        return _QuantLib.CallabilitySchedule_empty(self)

    def size(self):
        r"""size(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::size_type"""
        return _QuantLib.CallabilitySchedule_size(self)

    def swap(self, v):
        r"""swap(CallabilitySchedule self, CallabilitySchedule v)"""
        return _QuantLib.CallabilitySchedule_swap(self, v)

    def begin(self):
        r"""begin(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::iterator"""
        return _QuantLib.CallabilitySchedule_begin(self)

    def end(self):
        r"""end(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::iterator"""
        return _QuantLib.CallabilitySchedule_end(self)

    def rbegin(self):
        r"""rbegin(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::reverse_iterator"""
        return _QuantLib.CallabilitySchedule_rbegin(self)

    def rend(self):
        r"""rend(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::reverse_iterator"""
        return _QuantLib.CallabilitySchedule_rend(self)

    def clear(self):
        r"""clear(CallabilitySchedule self)"""
        return _QuantLib.CallabilitySchedule_clear(self)

    def get_allocator(self):
        r"""get_allocator(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::allocator_type"""
        return _QuantLib.CallabilitySchedule_get_allocator(self)

    def pop_back(self):
        r"""pop_back(CallabilitySchedule self)"""
        return _QuantLib.CallabilitySchedule_pop_back(self)

    def erase(self, *args):
        r"""
        erase(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator pos) -> std::vector< ext::shared_ptr< Callability > >::iterator
        erase(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator first, std::vector< ext::shared_ptr< Callability > >::iterator last) -> std::vector< ext::shared_ptr< Callability > >::iterator
        """
        return _QuantLib.CallabilitySchedule_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CallabilitySchedule self) -> CallabilitySchedule
        __init__(CallabilitySchedule self, CallabilitySchedule other) -> CallabilitySchedule
        __init__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type size) -> CallabilitySchedule
        __init__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type size, std::vector< ext::shared_ptr< Callability > >::value_type const & value) -> CallabilitySchedule
        """
        _QuantLib.CallabilitySchedule_swiginit(self, _QuantLib.new_CallabilitySchedule(*args))

    def push_back(self, x):
        r"""push_back(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::value_type const & x)"""
        return _QuantLib.CallabilitySchedule_push_back(self, x)

    def front(self):
        r"""front(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::value_type const &"""
        return _QuantLib.CallabilitySchedule_front(self)

    def back(self):
        r"""back(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::value_type const &"""
        return _QuantLib.CallabilitySchedule_back(self)

    def assign(self, n, x):
        r"""assign(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type n, std::vector< ext::shared_ptr< Callability > >::value_type const & x)"""
        return _QuantLib.CallabilitySchedule_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type new_size)
        resize(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type new_size, std::vector< ext::shared_ptr< Callability > >::value_type const & x)
        """
        return _QuantLib.CallabilitySchedule_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator pos, std::vector< ext::shared_ptr< Callability > >::value_type const & x) -> std::vector< ext::shared_ptr< Callability > >::iterator
        insert(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator pos, std::vector< ext::shared_ptr< Callability > >::size_type n, std::vector< ext::shared_ptr< Callability > >::value_type const & x)
        """
        return _QuantLib.CallabilitySchedule_insert(self, *args)

    def reserve(self, n):
        r"""reserve(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type n)"""
        return _QuantLib.CallabilitySchedule_reserve(self, n)

    def capacity(self):
        r"""capacity(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::size_type"""
        return _QuantLib.CallabilitySchedule_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CallabilitySchedule

# Register CallabilitySchedule in _QuantLib:
_QuantLib.CallabilitySchedule_swigregister(CallabilitySchedule)
class CallableBond(Bond):
    r"""Proxy of C++ CallableBond class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def callability(self):
        r"""callability(CallableBond self) -> CallabilitySchedule"""
        return _QuantLib.CallableBond_callability(self)

    def impliedVolatility(self, *args):
        r"""
        impliedVolatility(CallableBond self, BondPrice targetPrice, YieldTermStructureHandle discountCurve, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) -> Volatility
        impliedVolatility(CallableBond self, Real targetValue, YieldTermStructureHandle discountCurve, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) -> Volatility
        """
        return _QuantLib.CallableBond_impliedVolatility(self, *args)

    def OAS(self, *args):
        r"""OAS(CallableBond self, Real cleanPrice, YieldTermStructureHandle engineTS, DayCounter dc, Compounding compounding, Frequency freq, Date settlementDate=Date(), Real accuracy=1e-10, Size maxIterations=100, Spread guess=0.0) -> Real"""
        return _QuantLib.CallableBond_OAS(self, *args)

    def cleanPriceOAS(self, *args):
        r"""cleanPriceOAS(CallableBond self, Real oas, YieldTermStructureHandle engineTS, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real"""
        return _QuantLib.CallableBond_cleanPriceOAS(self, *args)

    def effectiveDuration(self, oas, engineTS, dayCounter, compounding, frequency, bump=2e-4):
        r"""effectiveDuration(CallableBond self, Real oas, YieldTermStructureHandle engineTS, DayCounter dayCounter, Compounding compounding, Frequency frequency, Real bump=2e-4) -> Real"""
        return _QuantLib.CallableBond_effectiveDuration(self, oas, engineTS, dayCounter, compounding, frequency, bump)

    def effectiveConvexity(self, oas, engineTS, dayCounter, compounding, frequency, bump=2e-4):
        r"""effectiveConvexity(CallableBond self, Real oas, YieldTermStructureHandle engineTS, DayCounter dayCounter, Compounding compounding, Frequency frequency, Real bump=2e-4) -> Real"""
        return _QuantLib.CallableBond_effectiveConvexity(self, oas, engineTS, dayCounter, compounding, frequency, bump)
    __swig_destroy__ = _QuantLib.delete_CallableBond

# Register CallableBond in _QuantLib:
_QuantLib.CallableBond_swigregister(CallableBond)
class CallableFixedRateBond(CallableBond):
    r"""Proxy of C++ CallableFixedRateBond class."""

    thisown = 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):
        r"""__init__(CallableFixedRateBond self, Integer settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention, Real redemption, Date issueDate, CallabilitySchedule putCallSchedule, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> CallableFixedRateBond"""
        _QuantLib.CallableFixedRateBond_swiginit(self, _QuantLib.new_CallableFixedRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CallableFixedRateBond

# Register CallableFixedRateBond in _QuantLib:
_QuantLib.CallableFixedRateBond_swigregister(CallableFixedRateBond)
class CallableZeroCouponBond(CallableBond):
    r"""Proxy of C++ CallableZeroCouponBond class."""

    thisown = 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):
        r"""__init__(CallableZeroCouponBond self, Integer settlementDays, Real faceAmount, Calendar calendar, Date maturityDate, DayCounter dayCounter, BusinessDayConvention paymentConvention=Following, Real redemption=100.0, Date issueDate=Date(), CallabilitySchedule putCallSchedule=std::vector< ext::shared_ptr< Callability > >()) -> CallableZeroCouponBond"""
        _QuantLib.CallableZeroCouponBond_swiginit(self, _QuantLib.new_CallableZeroCouponBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CallableZeroCouponBond

# Register CallableZeroCouponBond in _QuantLib:
_QuantLib.CallableZeroCouponBond_swigregister(CallableZeroCouponBond)
class TreeCallableFixedRateBondEngine(PricingEngine):
    r"""Proxy of C++ TreeCallableFixedRateBondEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(TreeCallableFixedRateBondEngine self, ext::shared_ptr< ShortRateModel > const & model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeCallableFixedRateBondEngine
        __init__(TreeCallableFixedRateBondEngine self, ext::shared_ptr< ShortRateModel > const & model, TimeGrid grid, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >()) -> TreeCallableFixedRateBondEngine
        """
        _QuantLib.TreeCallableFixedRateBondEngine_swiginit(self, _QuantLib.new_TreeCallableFixedRateBondEngine(*args))
    __swig_destroy__ = _QuantLib.delete_TreeCallableFixedRateBondEngine

# Register TreeCallableFixedRateBondEngine in _QuantLib:
_QuantLib.TreeCallableFixedRateBondEngine_swigregister(TreeCallableFixedRateBondEngine)
class BlackCallableFixedRateBondEngine(PricingEngine):
    r"""Proxy of C++ BlackCallableFixedRateBondEngine class."""

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

    def __init__(self, fwdYieldVol, discountCurve):
        r"""__init__(BlackCallableFixedRateBondEngine self, QuoteHandle fwdYieldVol, YieldTermStructureHandle discountCurve) -> BlackCallableFixedRateBondEngine"""
        _QuantLib.BlackCallableFixedRateBondEngine_swiginit(self, _QuantLib.new_BlackCallableFixedRateBondEngine(fwdYieldVol, discountCurve))
    __swig_destroy__ = _QuantLib.delete_BlackCallableFixedRateBondEngine

# Register BlackCallableFixedRateBondEngine in _QuantLib:
_QuantLib.BlackCallableFixedRateBondEngine_swigregister(BlackCallableFixedRateBondEngine)
class CPIBond(Bond):
    r"""Proxy of C++ CPIBond class."""

    thisown = 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):
        r"""__init__(CPIBond self, Natural settlementDays, Real faceAmount, bool growthOnly, Real baseCPI, Period observationLag, ext::shared_ptr< ZeroInflationIndex > const & cpiIndex, CPI::InterpolationType observationInterpolation, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=ModifiedFollowing, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> CPIBond"""
        _QuantLib.CPIBond_swiginit(self, _QuantLib.new_CPIBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CPIBond

# Register CPIBond in _QuantLib:
_QuantLib.CPIBond_swigregister(CPIBond)
class BondFunctions(object):
    r"""Proxy of C++ BondFunctions class."""

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

    @staticmethod
    def startDate(bond):
        r"""startDate(Bond bond) -> Date"""
        return _QuantLib.BondFunctions_startDate(bond)

    @staticmethod
    def maturityDate(bond):
        r"""maturityDate(Bond bond) -> Date"""
        return _QuantLib.BondFunctions_maturityDate(bond)

    @staticmethod
    def isTradable(*args):
        r"""isTradable(Bond bond, Date settlementDate=Date()) -> bool"""
        return _QuantLib.BondFunctions_isTradable(*args)

    @staticmethod
    def previousCashFlowDate(*args):
        r"""previousCashFlowDate(Bond bond, Date refDate=Date()) -> Date"""
        return _QuantLib.BondFunctions_previousCashFlowDate(*args)

    @staticmethod
    def nextCashFlowDate(*args):
        r"""nextCashFlowDate(Bond bond, Date refDate=Date()) -> Date"""
        return _QuantLib.BondFunctions_nextCashFlowDate(*args)

    @staticmethod
    def previousCashFlowAmount(*args):
        r"""previousCashFlowAmount(Bond bond, Date refDate=Date()) -> Real"""
        return _QuantLib.BondFunctions_previousCashFlowAmount(*args)

    @staticmethod
    def nextCashFlowAmount(*args):
        r"""nextCashFlowAmount(Bond bond, Date refDate=Date()) -> Real"""
        return _QuantLib.BondFunctions_nextCashFlowAmount(*args)

    @staticmethod
    def previousCouponRate(*args):
        r"""previousCouponRate(Bond bond, Date settlementDate=Date()) -> Rate"""
        return _QuantLib.BondFunctions_previousCouponRate(*args)

    @staticmethod
    def nextCouponRate(*args):
        r"""nextCouponRate(Bond bond, Date settlementDate=Date()) -> Rate"""
        return _QuantLib.BondFunctions_nextCouponRate(*args)

    @staticmethod
    def accrualStartDate(*args):
        r"""accrualStartDate(Bond bond, Date settlementDate=Date()) -> Date"""
        return _QuantLib.BondFunctions_accrualStartDate(*args)

    @staticmethod
    def accrualEndDate(*args):
        r"""accrualEndDate(Bond bond, Date settlementDate=Date()) -> Date"""
        return _QuantLib.BondFunctions_accrualEndDate(*args)

    @staticmethod
    def accrualPeriod(*args):
        r"""accrualPeriod(Bond bond, Date settlementDate=Date()) -> Time"""
        return _QuantLib.BondFunctions_accrualPeriod(*args)

    @staticmethod
    def accrualDays(*args):
        r"""accrualDays(Bond bond, Date settlementDate=Date()) -> BigInteger"""
        return _QuantLib.BondFunctions_accrualDays(*args)

    @staticmethod
    def accruedPeriod(*args):
        r"""accruedPeriod(Bond bond, Date settlementDate=Date()) -> Time"""
        return _QuantLib.BondFunctions_accruedPeriod(*args)

    @staticmethod
    def accruedDays(*args):
        r"""accruedDays(Bond bond, Date settlementDate=Date()) -> BigInteger"""
        return _QuantLib.BondFunctions_accruedDays(*args)

    @staticmethod
    def accruedAmount(*args):
        r"""accruedAmount(Bond bond, Date settlementDate=Date()) -> Real"""
        return _QuantLib.BondFunctions_accruedAmount(*args)

    @staticmethod
    def atmRate(*args):
        r"""atmRate(Bond bond, YieldTermStructure discountCurve, Date settlementDate=Date(), Real cleanPrice=Null< Real >()) -> Rate"""
        return _QuantLib.BondFunctions_atmRate(*args)

    @staticmethod
    def cleanPrice(*args):
        r"""
        cleanPrice(Bond bond, YieldTermStructure discountCurve, Date settlementDate=Date()) -> Real
        cleanPrice(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real
        cleanPrice(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real
        """
        return _QuantLib.BondFunctions_cleanPrice(*args)

    @staticmethod
    def bps(*args):
        r"""
        bps(Bond bond, YieldTermStructure discountCurve, Date settlementDate=Date()) -> Real
        bps(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real
        bps(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real
        """
        return _QuantLib.BondFunctions_bps(*args)

    @staticmethod
    def bondYield(*args):
        r"""bondYield(Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Size maxIterations=100, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_bondYield(*args)

    @staticmethod
    def duration(*args):
        r"""
        duration(Bond bond, InterestRate _yield, Duration::Type type=Modified, Date settlementDate=Date()) -> Time
        duration(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Duration::Type type=Modified, Date settlementDate=Date()) -> Time
        """
        return _QuantLib.BondFunctions_duration(*args)

    @staticmethod
    def convexity(*args):
        r"""
        convexity(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real
        convexity(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real
        """
        return _QuantLib.BondFunctions_convexity(*args)

    @staticmethod
    def basisPointValue(*args):
        r"""
        basisPointValue(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real
        basisPointValue(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real
        """
        return _QuantLib.BondFunctions_basisPointValue(*args)

    @staticmethod
    def yieldValueBasisPoint(*args):
        r"""
        yieldValueBasisPoint(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real
        yieldValueBasisPoint(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real
        """
        return _QuantLib.BondFunctions_yieldValueBasisPoint(*args)

    @staticmethod
    def zSpread(*args):
        r"""zSpread(Bond bond, Real cleanPrice, ext::shared_ptr< YieldTermStructure > const & discountCurve, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Size maxIterations=100, Rate guess=0.0) -> Spread"""
        return _QuantLib.BondFunctions_zSpread(*args)

    @staticmethod
    def yieldBrent(*args):
        r"""yieldBrent(Brent solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldBrent(*args)

    @staticmethod
    def yieldBisection(*args):
        r"""yieldBisection(Bisection solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldBisection(*args)

    @staticmethod
    def yieldFalsePosition(*args):
        r"""yieldFalsePosition(FalsePosition solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldFalsePosition(*args)

    @staticmethod
    def yieldRidder(*args):
        r"""yieldRidder(Ridder solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldRidder(*args)

    @staticmethod
    def yieldSecant(*args):
        r"""yieldSecant(Secant solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldSecant(*args)

    @staticmethod
    def yieldNewton(*args):
        r"""yieldNewton(Newton solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldNewton(*args)

    @staticmethod
    def yieldNewtonSafe(*args):
        r"""yieldNewtonSafe(NewtonSafe solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"""
        return _QuantLib.BondFunctions_yieldNewtonSafe(*args)

    def __init__(self):
        r"""__init__(BondFunctions self) -> BondFunctions"""
        _QuantLib.BondFunctions_swiginit(self, _QuantLib.new_BondFunctions())
    __swig_destroy__ = _QuantLib.delete_BondFunctions

# Register BondFunctions in _QuantLib:
_QuantLib.BondFunctions_swigregister(BondFunctions)
class CapFloor(Instrument):
    r"""Proxy of C++ CapFloor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def impliedVolatility(self, price, disc, guess, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0, type=ShiftedLognormal, displacement=0.0):
        r"""impliedVolatility(CapFloor self, Real price, YieldTermStructureHandle disc, Volatility guess, Real accuracy=1.0e-4, Natural maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0, VolatilityType type=ShiftedLognormal, Real displacement=0.0) -> Volatility"""
        return _QuantLib.CapFloor_impliedVolatility(self, price, disc, guess, accuracy, maxEvaluations, minVol, maxVol, type, displacement)
    Cap = _QuantLib.CapFloor_Cap
    
    Floor = _QuantLib.CapFloor_Floor
    
    Collar = _QuantLib.CapFloor_Collar
    

    def floatingLeg(self):
        r"""floatingLeg(CapFloor self) -> Leg"""
        return _QuantLib.CapFloor_floatingLeg(self)

    def capRates(self):
        r"""capRates(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_capRates(self)

    def floorRates(self):
        r"""floorRates(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_floorRates(self)

    def startDate(self):
        r"""startDate(CapFloor self) -> Date"""
        return _QuantLib.CapFloor_startDate(self)

    def maturityDate(self):
        r"""maturityDate(CapFloor self) -> Date"""
        return _QuantLib.CapFloor_maturityDate(self)

    def type(self):
        r"""type(CapFloor self) -> CapFloor::Type"""
        return _QuantLib.CapFloor_type(self)

    def atmRate(self, discountCurve):
        r"""atmRate(CapFloor self, YieldTermStructure discountCurve) -> Rate"""
        return _QuantLib.CapFloor_atmRate(self, discountCurve)

    def vega(self):
        r"""vega(CapFloor self) -> Real const"""
        return _QuantLib.CapFloor_vega(self)

    def optionletsPrice(self):
        r"""optionletsPrice(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_optionletsPrice(self)

    def optionletsVega(self):
        r"""optionletsVega(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_optionletsVega(self)

    def optionletsDelta(self):
        r"""optionletsDelta(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_optionletsDelta(self)

    def optionletsDiscountFactor(self):
        r"""optionletsDiscountFactor(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_optionletsDiscountFactor(self)

    def optionletsAtmForward(self):
        r"""optionletsAtmForward(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_optionletsAtmForward(self)

    def optionletsStdDev(self):
        r"""optionletsStdDev(CapFloor self) -> DoubleVector"""
        return _QuantLib.CapFloor_optionletsStdDev(self)
    __swig_destroy__ = _QuantLib.delete_CapFloor

# Register CapFloor in _QuantLib:
_QuantLib.CapFloor_swigregister(CapFloor)
class Cap(CapFloor):
    r"""Proxy of C++ Cap class."""

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

    def __init__(self, leg, capRates):
        r"""__init__(Cap self, Leg leg, DoubleVector capRates) -> Cap"""
        _QuantLib.Cap_swiginit(self, _QuantLib.new_Cap(leg, capRates))
    __swig_destroy__ = _QuantLib.delete_Cap

# Register Cap in _QuantLib:
_QuantLib.Cap_swigregister(Cap)
class Floor(CapFloor):
    r"""Proxy of C++ Floor class."""

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

    def __init__(self, leg, floorRates):
        r"""__init__(Floor self, Leg leg, DoubleVector floorRates) -> Floor"""
        _QuantLib.Floor_swiginit(self, _QuantLib.new_Floor(leg, floorRates))
    __swig_destroy__ = _QuantLib.delete_Floor

# Register Floor in _QuantLib:
_QuantLib.Floor_swigregister(Floor)
class Collar(CapFloor):
    r"""Proxy of C++ Collar class."""

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

    def __init__(self, leg, capRates, floorRates):
        r"""__init__(Collar self, Leg leg, DoubleVector capRates, DoubleVector floorRates) -> Collar"""
        _QuantLib.Collar_swiginit(self, _QuantLib.new_Collar(leg, capRates, floorRates))
    __swig_destroy__ = _QuantLib.delete_Collar

# Register Collar in _QuantLib:
_QuantLib.Collar_swigregister(Collar)
class BlackCapFloorEngine(PricingEngine):
    r"""Proxy of C++ BlackCapFloorEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(BlackCapFloorEngine self, YieldTermStructureHandle termStructure, QuoteHandle vol, DayCounter dc=Actual365Fixed(), Real displacement=0.0) -> BlackCapFloorEngine
        __init__(BlackCapFloorEngine self, YieldTermStructureHandle termStructure, OptionletVolatilityStructureHandle vol, Real displacement=Null< Real >()) -> BlackCapFloorEngine
        """
        _QuantLib.BlackCapFloorEngine_swiginit(self, _QuantLib.new_BlackCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BlackCapFloorEngine

# Register BlackCapFloorEngine in _QuantLib:
_QuantLib.BlackCapFloorEngine_swigregister(BlackCapFloorEngine)
class BachelierCapFloorEngine(PricingEngine):
    r"""Proxy of C++ BachelierCapFloorEngine class."""

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

    def __init__(self, *args):
        r"""
        __init__(BachelierCapFloorEngine self, YieldTermStructureHandle termStructure, QuoteHandle vol) -> BachelierCapFloorEngine
        __init__(BachelierCapFloorEngine self, YieldTermStructureHandle termStructure, OptionletVolatilityStructureHandle vol) -> BachelierCapFloorEngine
        """
        _QuantLib.BachelierCapFloorEngine_swiginit(self, _QuantLib.new_BachelierCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BachelierCapFloorEngine

# Register BachelierCapFloorEngine in _QuantLib:
_QuantLib.BachelierCapFloorEngine_swigregister(BachelierCapFloorEngine)
class CliquetOption(OneAssetOption):
    r"""Proxy of C++ CliquetOption class."""

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

    def __init__(self, payoff, maturity, resetDates):
        r"""__init__(CliquetOption self, ext::shared_ptr< PercentageStrikePayoff > const & payoff, ext::shared_ptr< EuropeanExercise > const & maturity, DateVector resetDates) -> CliquetOption"""
        _QuantLib.CliquetOption_swiginit(self, _QuantLib.new_CliquetOption(payoff, maturity, resetDates))
    __swig_destroy__ = _QuantLib.delete_CliquetOption

# Register CliquetOption in _QuantLib:
_QuantLib.CliquetOption_swigregister(CliquetOption)
class AnalyticCliquetEngine(PricingEngine):
    r"""Proxy of C++ AnalyticCliquetEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticCliquetEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticCliquetEngine"""
        _QuantLib.AnalyticCliquetEngine_swiginit(self, _QuantLib.new_AnalyticCliquetEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticCliquetEngine

# Register AnalyticCliquetEngine in _QuantLib:
_QuantLib.AnalyticCliquetEngine_swigregister(AnalyticCliquetEngine)
class AnalyticPerformanceEngine(PricingEngine):
    r"""Proxy of C++ AnalyticPerformanceEngine class."""

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

    def __init__(self, process):
        r"""__init__(AnalyticPerformanceEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const process) -> AnalyticPerformanceEngine"""
        _QuantLib.AnalyticPerformanceEngine_swiginit(self, _QuantLib.new_AnalyticPerformanceEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticPerformanceEngine

# Register AnalyticPerformanceEngine in _QuantLib:
_QuantLib.AnalyticPerformanceEngine_swigregister(AnalyticPerformanceEngine)
class MCPRPerformanceEngine(PricingEngine):
    r"""Proxy of C++ MCPerformanceEngine< PseudoRandom > class."""

    thisown = 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):
        r"""__init__(MCPRPerformanceEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRPerformanceEngine"""
        _QuantLib.MCPRPerformanceEngine_swiginit(self, _QuantLib.new_MCPRPerformanceEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRPerformanceEngine

# Register MCPRPerformanceEngine in _QuantLib:
_QuantLib.MCPRPerformanceEngine_swigregister(MCPRPerformanceEngine)
class MCLDPerformanceEngine(PricingEngine):
    r"""Proxy of C++ MCPerformanceEngine< LowDiscrepancy > class."""

    thisown = 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):
        r"""__init__(MCLDPerformanceEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDPerformanceEngine"""
        _QuantLib.MCLDPerformanceEngine_swiginit(self, _QuantLib.new_MCLDPerformanceEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDPerformanceEngine

# Register MCLDPerformanceEngine in _QuantLib:
_QuantLib.MCLDPerformanceEngine_swigregister(MCLDPerformanceEngine)

def MCPerformanceEngine(process,
                        traits,
                        brownianBridge=False,
                        antitheticVariate=False,
                        requiredSamples=None,
                        requiredTolerance=None,
                        maxSamples=None,
                        seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRPerformanceEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDPerformanceEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class Dividend(CashFlow):
    r"""Proxy of C++ Dividend class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register Dividend in _QuantLib:
_QuantLib.Dividend_swigregister(Dividend)
class FixedDividend(Dividend):
    r"""Proxy of C++ FixedDividend class."""

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

    def __init__(self, amount, date):
        r"""__init__(FixedDividend self, Real amount, Date date) -> FixedDividend"""
        _QuantLib.FixedDividend_swiginit(self, _QuantLib.new_FixedDividend(amount, date))
    __swig_destroy__ = _QuantLib.delete_FixedDividend

# Register FixedDividend in _QuantLib:
_QuantLib.FixedDividend_swigregister(FixedDividend)
class FractionalDividend(Dividend):
    r"""Proxy of C++ FractionalDividend class."""

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

    def __init__(self, rate, date):
        r"""__init__(FractionalDividend self, Rate rate, Date date) -> FractionalDividend"""
        _QuantLib.FractionalDividend_swiginit(self, _QuantLib.new_FractionalDividend(rate, date))
    __swig_destroy__ = _QuantLib.delete_FractionalDividend

# Register FractionalDividend in _QuantLib:
_QuantLib.FractionalDividend_swigregister(FractionalDividend)
class DividendSchedule(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< Dividend > > class."""

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

    def iterator(self):
        r"""iterator(DividendSchedule self) -> SwigPyIterator"""
        return _QuantLib.DividendSchedule_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DividendSchedule self) -> bool"""
        return _QuantLib.DividendSchedule___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DividendSchedule self) -> bool"""
        return _QuantLib.DividendSchedule___bool__(self)

    def __len__(self):
        r"""__len__(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::size_type"""
        return _QuantLib.DividendSchedule___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j) -> DividendSchedule"""
        return _QuantLib.DividendSchedule___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j)
        __setslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j, DividendSchedule v)
        """
        return _QuantLib.DividendSchedule___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j)"""
        return _QuantLib.DividendSchedule___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i)
        __delitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.DividendSchedule___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice) -> DividendSchedule
        __getitem__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i) -> std::vector< ext::shared_ptr< Dividend > >::value_type const &
        """
        return _QuantLib.DividendSchedule___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice, DividendSchedule v)
        __setitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)
        """
        return _QuantLib.DividendSchedule___setitem__(self, *args)

    def pop(self):
        r"""pop(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::value_type"""
        return _QuantLib.DividendSchedule_pop(self)

    def append(self, x):
        r"""append(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)"""
        return _QuantLib.DividendSchedule_append(self, x)

    def empty(self):
        r"""empty(DividendSchedule self) -> bool"""
        return _QuantLib.DividendSchedule_empty(self)

    def size(self):
        r"""size(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::size_type"""
        return _QuantLib.DividendSchedule_size(self)

    def swap(self, v):
        r"""swap(DividendSchedule self, DividendSchedule v)"""
        return _QuantLib.DividendSchedule_swap(self, v)

    def begin(self):
        r"""begin(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::iterator"""
        return _QuantLib.DividendSchedule_begin(self)

    def end(self):
        r"""end(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::iterator"""
        return _QuantLib.DividendSchedule_end(self)

    def rbegin(self):
        r"""rbegin(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::reverse_iterator"""
        return _QuantLib.DividendSchedule_rbegin(self)

    def rend(self):
        r"""rend(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::reverse_iterator"""
        return _QuantLib.DividendSchedule_rend(self)

    def clear(self):
        r"""clear(DividendSchedule self)"""
        return _QuantLib.DividendSchedule_clear(self)

    def get_allocator(self):
        r"""get_allocator(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::allocator_type"""
        return _QuantLib.DividendSchedule_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DividendSchedule self)"""
        return _QuantLib.DividendSchedule_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator pos) -> std::vector< ext::shared_ptr< Dividend > >::iterator
        erase(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator first, std::vector< ext::shared_ptr< Dividend > >::iterator last) -> std::vector< ext::shared_ptr< Dividend > >::iterator
        """
        return _QuantLib.DividendSchedule_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DividendSchedule self) -> DividendSchedule
        __init__(DividendSchedule self, DividendSchedule other) -> DividendSchedule
        __init__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type size) -> DividendSchedule
        __init__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type size, std::vector< ext::shared_ptr< Dividend > >::value_type const & value) -> DividendSchedule
        """
        _QuantLib.DividendSchedule_swiginit(self, _QuantLib.new_DividendSchedule(*args))

    def push_back(self, x):
        r"""push_back(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)"""
        return _QuantLib.DividendSchedule_push_back(self, x)

    def front(self):
        r"""front(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::value_type const &"""
        return _QuantLib.DividendSchedule_front(self)

    def back(self):
        r"""back(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::value_type const &"""
        return _QuantLib.DividendSchedule_back(self)

    def assign(self, n, x):
        r"""assign(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type n, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)"""
        return _QuantLib.DividendSchedule_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type new_size)
        resize(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type new_size, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)
        """
        return _QuantLib.DividendSchedule_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator pos, std::vector< ext::shared_ptr< Dividend > >::value_type const & x) -> std::vector< ext::shared_ptr< Dividend > >::iterator
        insert(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator pos, std::vector< ext::shared_ptr< Dividend > >::size_type n, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)
        """
        return _QuantLib.DividendSchedule_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type n)"""
        return _QuantLib.DividendSchedule_reserve(self, n)

    def capacity(self):
        r"""capacity(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::size_type"""
        return _QuantLib.DividendSchedule_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DividendSchedule

# Register DividendSchedule in _QuantLib:
_QuantLib.DividendSchedule_swigregister(DividendSchedule)
class ConvertibleZeroCouponBond(Bond):
    r"""Proxy of C++ ConvertibleZeroCouponBond class."""

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

    def __init__(self, exercise, conversionRatio, callability, issueDate, settlementDays, dayCounter, schedule, redemption=100.0):
        r"""__init__(ConvertibleZeroCouponBond self, ext::shared_ptr< Exercise > const & exercise, Real conversionRatio, CallabilitySchedule callability, Date issueDate, Integer settlementDays, DayCounter dayCounter, Schedule schedule, Real redemption=100.0) -> ConvertibleZeroCouponBond"""
        _QuantLib.ConvertibleZeroCouponBond_swiginit(self, _QuantLib.new_ConvertibleZeroCouponBond(exercise, conversionRatio, callability, issueDate, settlementDays, dayCounter, schedule, redemption))
    __swig_destroy__ = _QuantLib.delete_ConvertibleZeroCouponBond

# Register ConvertibleZeroCouponBond in _QuantLib:
_QuantLib.ConvertibleZeroCouponBond_swigregister(ConvertibleZeroCouponBond)
class ConvertibleFixedCouponBond(Bond):
    r"""Proxy of C++ ConvertibleFixedCouponBond class."""

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

    def __init__(self, *args):
        r"""__init__(ConvertibleFixedCouponBond self, ext::shared_ptr< Exercise > const & exercise, Real conversionRatio, CallabilitySchedule callability, Date issueDate, Integer settlementDays, DoubleVector coupons, DayCounter dayCounter, Schedule schedule, Real redemption=100.0, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> ConvertibleFixedCouponBond"""
        _QuantLib.ConvertibleFixedCouponBond_swiginit(self, _QuantLib.new_ConvertibleFixedCouponBond(*args))
    __swig_destroy__ = _QuantLib.delete_ConvertibleFixedCouponBond

# Register ConvertibleFixedCouponBond in _QuantLib:
_QuantLib.ConvertibleFixedCouponBond_swigregister(ConvertibleFixedCouponBond)
class ConvertibleFloatingRateBond(Bond):
    r"""Proxy of C++ ConvertibleFloatingRateBond class."""

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

    def __init__(self, *args):
        r"""__init__(ConvertibleFloatingRateBond self, ext::shared_ptr< Exercise > const & exercise, Real conversionRatio, CallabilitySchedule callability, Date issueDate, Integer settlementDays, ext::shared_ptr< IborIndex > const & index, Integer fixingDays, DoubleVector spreads, DayCounter dayCounter, Schedule schedule, Real redemption=100.0, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> ConvertibleFloatingRateBond"""
        _QuantLib.ConvertibleFloatingRateBond_swiginit(self, _QuantLib.new_ConvertibleFloatingRateBond(*args))
    __swig_destroy__ = _QuantLib.delete_ConvertibleFloatingRateBond

# Register ConvertibleFloatingRateBond in _QuantLib:
_QuantLib.ConvertibleFloatingRateBond_swigregister(ConvertibleFloatingRateBond)
class BinomialCRRConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< CoxRossRubinstein > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialCRRConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialCRRConvertibleEngine"""
        _QuantLib.BinomialCRRConvertibleEngine_swiginit(self, _QuantLib.new_BinomialCRRConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRConvertibleEngine

# Register BinomialCRRConvertibleEngine in _QuantLib:
_QuantLib.BinomialCRRConvertibleEngine_swigregister(BinomialCRRConvertibleEngine)
class BinomialJRConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< JarrowRudd > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialJRConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialJRConvertibleEngine"""
        _QuantLib.BinomialJRConvertibleEngine_swiginit(self, _QuantLib.new_BinomialJRConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialJRConvertibleEngine

# Register BinomialJRConvertibleEngine in _QuantLib:
_QuantLib.BinomialJRConvertibleEngine_swigregister(BinomialJRConvertibleEngine)
class BinomialEQPConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< AdditiveEQPBinomialTree > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialEQPConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialEQPConvertibleEngine"""
        _QuantLib.BinomialEQPConvertibleEngine_swiginit(self, _QuantLib.new_BinomialEQPConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPConvertibleEngine

# Register BinomialEQPConvertibleEngine in _QuantLib:
_QuantLib.BinomialEQPConvertibleEngine_swigregister(BinomialEQPConvertibleEngine)
class BinomialTrigeorgisConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< Trigeorgis > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialTrigeorgisConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialTrigeorgisConvertibleEngine"""
        _QuantLib.BinomialTrigeorgisConvertibleEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisConvertibleEngine

# Register BinomialTrigeorgisConvertibleEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisConvertibleEngine_swigregister(BinomialTrigeorgisConvertibleEngine)
class BinomialTianConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< Tian > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialTianConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialTianConvertibleEngine"""
        _QuantLib.BinomialTianConvertibleEngine_swiginit(self, _QuantLib.new_BinomialTianConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialTianConvertibleEngine

# Register BinomialTianConvertibleEngine in _QuantLib:
_QuantLib.BinomialTianConvertibleEngine_swigregister(BinomialTianConvertibleEngine)
class BinomialLRConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< LeisenReimer > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialLRConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialLRConvertibleEngine"""
        _QuantLib.BinomialLRConvertibleEngine_swiginit(self, _QuantLib.new_BinomialLRConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialLRConvertibleEngine

# Register BinomialLRConvertibleEngine in _QuantLib:
_QuantLib.BinomialLRConvertibleEngine_swigregister(BinomialLRConvertibleEngine)
class BinomialJ4ConvertibleEngine(PricingEngine):
    r"""Proxy of C++ BinomialConvertibleEngine< Joshi4 > class."""

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

    def __init__(self, *args):
        r"""__init__(BinomialJ4ConvertibleEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > arg2, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >()) -> BinomialJ4ConvertibleEngine"""
        _QuantLib.BinomialJ4ConvertibleEngine_swiginit(self, _QuantLib.new_BinomialJ4ConvertibleEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4ConvertibleEngine

# Register BinomialJ4ConvertibleEngine in _QuantLib:
_QuantLib.BinomialJ4ConvertibleEngine_swigregister(BinomialJ4ConvertibleEngine)

def BinomialConvertibleEngine(process, type, steps, creditSpread, dividends=[]):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRConvertibleEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRConvertibleEngine
    elif type == "eqp":
        cls = BinomialEQPConvertibleEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisConvertibleEngine
    elif type == "tian":
        cls = BinomialTianConvertibleEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRConvertibleEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4ConvertibleEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps, creditSpread, dividends)

class Forward(Instrument):
    r"""Proxy of C++ Forward class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def settlementDate(self):
        r"""settlementDate(Forward self) -> Date"""
        return _QuantLib.Forward_settlementDate(self)

    def isExpired(self):
        r"""isExpired(Forward self) -> bool"""
        return _QuantLib.Forward_isExpired(self)

    def calendar(self):
        r"""calendar(Forward self) -> Calendar"""
        return _QuantLib.Forward_calendar(self)

    def businessDayConvention(self):
        r"""businessDayConvention(Forward self) -> BusinessDayConvention"""
        return _QuantLib.Forward_businessDayConvention(self)

    def dayCounter(self):
        r"""dayCounter(Forward self) -> DayCounter"""
        return _QuantLib.Forward_dayCounter(self)

    def discountCurve(self):
        r"""discountCurve(Forward self) -> YieldTermStructureHandle"""
        return _QuantLib.Forward_discountCurve(self)

    def incomeDiscountCurve(self):
        r"""incomeDiscountCurve(Forward self) -> YieldTermStructureHandle"""
        return _QuantLib.Forward_incomeDiscountCurve(self)

    def spotValue(self):
        r"""spotValue(Forward self) -> Real"""
        return _QuantLib.Forward_spotValue(self)

    def spotIncome(self, incomeDiscountCurve):
        r"""spotIncome(Forward self, YieldTermStructureHandle incomeDiscountCurve) -> Real"""
        return _QuantLib.Forward_spotIncome(self, incomeDiscountCurve)

    def forwardValue(self):
        r"""forwardValue(Forward self) -> Real"""
        return _QuantLib.Forward_forwardValue(self)

    def impliedYield(self, underlyingSpotValue, forwardValue, settlementDate, compoundingConvention, dayCounter):
        r"""impliedYield(Forward self, Real underlyingSpotValue, Real forwardValue, Date settlementDate, Compounding compoundingConvention, DayCounter dayCounter) -> InterestRate"""
        return _QuantLib.Forward_impliedYield(self, underlyingSpotValue, forwardValue, settlementDate, compoundingConvention, dayCounter)
    __swig_destroy__ = _QuantLib.delete_Forward

# Register Forward in _QuantLib:
_QuantLib.Forward_swigregister(Forward)
class BondForward(Forward):
    r"""Proxy of C++ BondForward class."""

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

    def __init__(self, *args):
        r"""__init__(BondForward self, Date valueDate, Date maturityDate, Position::Type type, Real strike, Natural settlementDays, DayCounter dayCounter, Calendar calendar, BusinessDayConvention businessDayConvention, ext::shared_ptr< Bond > const & bond, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), YieldTermStructureHandle incomeDiscountCurve=Handle< YieldTermStructure >()) -> BondForward"""
        _QuantLib.BondForward_swiginit(self, _QuantLib.new_BondForward(*args))

    def forwardPrice(self):
        r"""forwardPrice(BondForward self) -> Real"""
        return _QuantLib.BondForward_forwardPrice(self)

    def cleanForwardPrice(self):
        r"""cleanForwardPrice(BondForward self) -> Real"""
        return _QuantLib.BondForward_cleanForwardPrice(self)
    __swig_destroy__ = _QuantLib.delete_BondForward

# Register BondForward in _QuantLib:
_QuantLib.BondForward_swigregister(BondForward)
class FixedRateBondForward(BondForward):
    r"""Proxy of C++ FixedRateBondForward class."""

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

    def __init__(self, *args):
        r"""__init__(FixedRateBondForward self, Date valueDate, Date maturityDate, Position::Type type, Real strike, Natural settlementDays, DayCounter dayCounter, Calendar calendar, BusinessDayConvention businessDayConvention, ext::shared_ptr< FixedRateBond > const & fixedBond, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), YieldTermStructureHandle incomeDiscountCurve=Handle< YieldTermStructure >()) -> FixedRateBondForward"""
        _QuantLib.FixedRateBondForward_swiginit(self, _QuantLib.new_FixedRateBondForward(*args))
    __swig_destroy__ = _QuantLib.delete_FixedRateBondForward

# Register FixedRateBondForward in _QuantLib:
_QuantLib.FixedRateBondForward_swigregister(FixedRateBondForward)
class Futures(object):
    r"""Proxy of C++ Futures class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IMM = _QuantLib.Futures_IMM
    
    ASX = _QuantLib.Futures_ASX
    

    def __init__(self):
        r"""__init__(Futures self) -> Futures"""
        _QuantLib.Futures_swiginit(self, _QuantLib.new_Futures())
    __swig_destroy__ = _QuantLib.delete_Futures

# Register Futures in _QuantLib:
_QuantLib.Futures_swigregister(Futures)
class OvernightIndexFuture(Instrument):
    r"""Proxy of C++ OvernightIndexFuture class."""

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

    def __init__(self, *args):
        r"""__init__(OvernightIndexFuture self, ext::shared_ptr< OvernightIndex > overnightIndex, Date valueDate, Date maturityDate, QuoteHandle convexityAdjustment=Handle< Quote >(), RateAveraging::Type averagingMethod=Compound) -> OvernightIndexFuture"""
        _QuantLib.OvernightIndexFuture_swiginit(self, _QuantLib.new_OvernightIndexFuture(*args))

    def convexityAdjustment(self):
        r"""convexityAdjustment(OvernightIndexFuture self) -> Real"""
        return _QuantLib.OvernightIndexFuture_convexityAdjustment(self)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexFuture

# Register OvernightIndexFuture in _QuantLib:
_QuantLib.OvernightIndexFuture_swigregister(OvernightIndexFuture)
class Pillar(object):
    r"""Proxy of C++ Pillar class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MaturityDate = _QuantLib.Pillar_MaturityDate
    
    LastRelevantDate = _QuantLib.Pillar_LastRelevantDate
    
    CustomDate = _QuantLib.Pillar_CustomDate
    

    def __init__(self):
        r"""__init__(Pillar self) -> Pillar"""
        _QuantLib.Pillar_swiginit(self, _QuantLib.new_Pillar())
    __swig_destroy__ = _QuantLib.delete_Pillar

# Register Pillar in _QuantLib:
_QuantLib.Pillar_swigregister(Pillar)
class RateHelper(Observable):
    r"""Proxy of C++ RateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def quote(self):
        r"""quote(RateHelper self) -> QuoteHandle"""
        return _QuantLib.RateHelper_quote(self)

    def latestDate(self):
        r"""latestDate(RateHelper self) -> Date"""
        return _QuantLib.RateHelper_latestDate(self)

    def earliestDate(self):
        r"""earliestDate(RateHelper self) -> Date"""
        return _QuantLib.RateHelper_earliestDate(self)

    def maturityDate(self):
        r"""maturityDate(RateHelper self) -> Date"""
        return _QuantLib.RateHelper_maturityDate(self)

    def latestRelevantDate(self):
        r"""latestRelevantDate(RateHelper self) -> Date"""
        return _QuantLib.RateHelper_latestRelevantDate(self)

    def pillarDate(self):
        r"""pillarDate(RateHelper self) -> Date"""
        return _QuantLib.RateHelper_pillarDate(self)

    def impliedQuote(self):
        r"""impliedQuote(RateHelper self) -> Real"""
        return _QuantLib.RateHelper_impliedQuote(self)

    def quoteError(self):
        r"""quoteError(RateHelper self) -> Real"""
        return _QuantLib.RateHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_RateHelper

# Register RateHelper in _QuantLib:
_QuantLib.RateHelper_swigregister(RateHelper)
class DepositRateHelper(RateHelper):
    r"""Proxy of C++ DepositRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(DepositRateHelper self, QuoteHandle rate, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter) -> DepositRateHelper
        __init__(DepositRateHelper self, Rate rate, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter) -> DepositRateHelper
        __init__(DepositRateHelper self, QuoteHandle rate, ext::shared_ptr< IborIndex > const & index) -> DepositRateHelper
        __init__(DepositRateHelper self, Rate rate, ext::shared_ptr< IborIndex > const & index) -> DepositRateHelper
        """
        _QuantLib.DepositRateHelper_swiginit(self, _QuantLib.new_DepositRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_DepositRateHelper

# Register DepositRateHelper in _QuantLib:
_QuantLib.DepositRateHelper_swigregister(DepositRateHelper)
class FraRateHelper(RateHelper):
    r"""Proxy of C++ FraRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FraRateHelper self, QuoteHandle rate, Natural monthsToStart, Natural monthsToEnd, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, Rate rate, Natural monthsToStart, Natural monthsToEnd, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, QuoteHandle rate, Natural monthsToStart, ext::shared_ptr< IborIndex > const & index, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, Rate rate, Natural monthsToStart, ext::shared_ptr< IborIndex > const & index, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, QuoteHandle rate, Natural immOffsetStart, Natural immOffsetEnd, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, Rate rate, Natural immOffsetStart, Natural immOffsetEnd, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, Rate rate, Period periodToStart, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        __init__(FraRateHelper self, QuoteHandle rate, Period periodToStart, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True) -> FraRateHelper
        """
        _QuantLib.FraRateHelper_swiginit(self, _QuantLib.new_FraRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_FraRateHelper

# Register FraRateHelper in _QuantLib:
_QuantLib.FraRateHelper_swigregister(FraRateHelper)
class FuturesRateHelper(RateHelper):
    r"""Proxy of C++ FuturesRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FuturesRateHelper self, QuoteHandle price, Date iborStartDate, Natural nMonths, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, QuoteHandle convexityAdjustment=Handle< Quote >(), Futures::Type type=IMM) -> FuturesRateHelper
        __init__(FuturesRateHelper self, Real price, Date iborStartDate, Natural nMonths, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, Rate convexityAdjustment=0.0, Futures::Type type=IMM) -> FuturesRateHelper
        __init__(FuturesRateHelper self, QuoteHandle price, Date iborStartDate, Date iborEndDate, DayCounter dayCounter, QuoteHandle convexityAdjustment=Handle< Quote >(), Futures::Type type=IMM) -> FuturesRateHelper
        __init__(FuturesRateHelper self, Real price, Date iborStartDate, Date iborEndDate, DayCounter dayCounter, Rate convexityAdjustment=0.0, Futures::Type type=IMM) -> FuturesRateHelper
        __init__(FuturesRateHelper self, QuoteHandle price, Date iborStartDate, ext::shared_ptr< IborIndex > const & index, QuoteHandle convexityAdjustment=Handle< Quote >(), Futures::Type type=IMM) -> FuturesRateHelper
        __init__(FuturesRateHelper self, Real price, Date iborStartDate, ext::shared_ptr< IborIndex > const & index, Real convexityAdjustment=0.0, Futures::Type type=IMM) -> FuturesRateHelper
        """
        _QuantLib.FuturesRateHelper_swiginit(self, _QuantLib.new_FuturesRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_FuturesRateHelper

# Register FuturesRateHelper in _QuantLib:
_QuantLib.FuturesRateHelper_swigregister(FuturesRateHelper)
class SwapRateHelper(RateHelper):
    r"""Proxy of C++ SwapRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SwapRateHelper self, QuoteHandle rate, Period tenor, Calendar calendar, Frequency fixedFrequency, BusinessDayConvention fixedConvention, DayCounter fixedDayCount, ext::shared_ptr< IborIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >(), Natural settlementDays=Null< Natural >(), Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, boost::optional< bool > withIndexedCoupons=boost::none) -> SwapRateHelper
        __init__(SwapRateHelper self, Rate rate, Period tenor, Calendar calendar, Frequency fixedFrequency, BusinessDayConvention fixedConvention, DayCounter fixedDayCount, ext::shared_ptr< IborIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >(), Natural settlementDays=Null< Natural >(), Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, boost::optional< bool > withIndexedCoupons=boost::none) -> SwapRateHelper
        __init__(SwapRateHelper self, QuoteHandle rate, ext::shared_ptr< SwapIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >(), Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, boost::optional< bool > withIndexedCoupons=boost::none) -> SwapRateHelper
        __init__(SwapRateHelper self, Rate rate, ext::shared_ptr< SwapIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >(), Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, boost::optional< bool > withIndexedCoupons=boost::none) -> SwapRateHelper
        """
        _QuantLib.SwapRateHelper_swiginit(self, _QuantLib.new_SwapRateHelper(*args))

    def spread(self):
        r"""spread(SwapRateHelper self) -> Spread"""
        return _QuantLib.SwapRateHelper_spread(self)

    def swap(self):
        r"""swap(SwapRateHelper self) -> ext::shared_ptr< VanillaSwap >"""
        return _QuantLib.SwapRateHelper_swap(self)
    __swig_destroy__ = _QuantLib.delete_SwapRateHelper

# Register SwapRateHelper in _QuantLib:
_QuantLib.SwapRateHelper_swigregister(SwapRateHelper)
class BondHelper(RateHelper):
    r"""Proxy of C++ BondHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(BondHelper self, QuoteHandle cleanPrice, ext::shared_ptr< Bond > const & bond, BondPrice::Type priceType=Clean) -> BondHelper"""
        _QuantLib.BondHelper_swiginit(self, _QuantLib.new_BondHelper(*args))

    def bond(self):
        r"""bond(BondHelper self) -> ext::shared_ptr< Bond >"""
        return _QuantLib.BondHelper_bond(self)
    __swig_destroy__ = _QuantLib.delete_BondHelper

# Register BondHelper in _QuantLib:
_QuantLib.BondHelper_swigregister(BondHelper)
class FixedRateBondHelper(BondHelper):
    r"""Proxy of C++ FixedRateBondHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FixedRateBondHelper self, QuoteHandle cleanPrice, Size settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, BondPrice::Type priceType=Clean) -> FixedRateBondHelper"""
        _QuantLib.FixedRateBondHelper_swiginit(self, _QuantLib.new_FixedRateBondHelper(*args))

    def fixedRateBond(self):
        r"""fixedRateBond(FixedRateBondHelper self) -> ext::shared_ptr< FixedRateBond >"""
        return _QuantLib.FixedRateBondHelper_fixedRateBond(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBondHelper

# Register FixedRateBondHelper in _QuantLib:
_QuantLib.FixedRateBondHelper_swigregister(FixedRateBondHelper)
class OISRateHelper(RateHelper):
    r"""Proxy of C++ OISRateHelper class."""

    thisown = 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):
        r"""__init__(OISRateHelper self, Natural settlementDays, Period tenor, QuoteHandle rate, ext::shared_ptr< OvernightIndex > const & index, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >(), bool telescopicValueDates=False, Natural paymentLag=0, BusinessDayConvention paymentConvention=Following, Frequency paymentFrequency=Annual, Calendar paymentCalendar=Calendar(), Period forwardStart=0*Days, Spread const overnightSpread=0.0, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), RateAveraging::Type averagingMethod=Compound, boost::optional< bool > endOfMonth=boost::none) -> OISRateHelper"""
        _QuantLib.OISRateHelper_swiginit(self, _QuantLib.new_OISRateHelper(*args, **kwargs))

    def swap(self):
        r"""swap(OISRateHelper self) -> ext::shared_ptr< OvernightIndexedSwap >"""
        return _QuantLib.OISRateHelper_swap(self)
    __swig_destroy__ = _QuantLib.delete_OISRateHelper

# Register OISRateHelper in _QuantLib:
_QuantLib.OISRateHelper_swigregister(OISRateHelper)
class DatedOISRateHelper(RateHelper):
    r"""Proxy of C++ DatedOISRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DatedOISRateHelper self, Date startDate, Date endDate, QuoteHandle rate, ext::shared_ptr< OvernightIndex > const & index, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound) -> DatedOISRateHelper"""
        _QuantLib.DatedOISRateHelper_swiginit(self, _QuantLib.new_DatedOISRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_DatedOISRateHelper

# Register DatedOISRateHelper in _QuantLib:
_QuantLib.DatedOISRateHelper_swigregister(DatedOISRateHelper)
class FxSwapRateHelper(RateHelper):
    r"""Proxy of C++ FxSwapRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FxSwapRateHelper self, QuoteHandle fwdPoint, QuoteHandle spotFx, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, bool isFxBaseCurrencyCollateralCurrency, YieldTermStructureHandle collateralCurve, Calendar tradingCalendar=Calendar()) -> FxSwapRateHelper"""
        _QuantLib.FxSwapRateHelper_swiginit(self, _QuantLib.new_FxSwapRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_FxSwapRateHelper

# Register FxSwapRateHelper in _QuantLib:
_QuantLib.FxSwapRateHelper_swigregister(FxSwapRateHelper)
class OvernightIndexFutureRateHelper(RateHelper):
    r"""Proxy of C++ OvernightIndexFutureRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(OvernightIndexFutureRateHelper self, QuoteHandle price, Date valueDate, Date maturityDate, ext::shared_ptr< OvernightIndex > const & index, QuoteHandle convexityAdjustment=Handle< Quote >(), RateAveraging::Type averagingMethod=Compound) -> OvernightIndexFutureRateHelper"""
        _QuantLib.OvernightIndexFutureRateHelper_swiginit(self, _QuantLib.new_OvernightIndexFutureRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_OvernightIndexFutureRateHelper

# Register OvernightIndexFutureRateHelper in _QuantLib:
_QuantLib.OvernightIndexFutureRateHelper_swigregister(OvernightIndexFutureRateHelper)
class SofrFutureRateHelper(OvernightIndexFutureRateHelper):
    r"""Proxy of C++ SofrFutureRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SofrFutureRateHelper self, QuoteHandle price, Month referenceMonth, Year referenceYear, Frequency referenceFreq, ext::shared_ptr< OvernightIndex > const & index, QuoteHandle convexityAdjustment=Handle< Quote >(), RateAveraging::Type averagingMethod=Compound) -> SofrFutureRateHelper
        __init__(SofrFutureRateHelper self, Real price, Month referenceMonth, Year referenceYear, Frequency referenceFreq, ext::shared_ptr< OvernightIndex > const & index, Real convexityAdjustment=0.0, RateAveraging::Type averagingMethod=Compound) -> SofrFutureRateHelper
        __init__(SofrFutureRateHelper self, QuoteHandle price, Month referenceMonth, Year referenceYear, Frequency referenceFreq, QuoteHandle convexityAdjustment=Handle< Quote >()) -> SofrFutureRateHelper
        __init__(SofrFutureRateHelper self, Real price, Month referenceMonth, Year referenceYear, Frequency referenceFreq, Real convexityAdjustment=0.0) -> SofrFutureRateHelper
        """
        _QuantLib.SofrFutureRateHelper_swiginit(self, _QuantLib.new_SofrFutureRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_SofrFutureRateHelper

# Register SofrFutureRateHelper in _QuantLib:
_QuantLib.SofrFutureRateHelper_swigregister(SofrFutureRateHelper)
class ConstNotionalCrossCurrencyBasisSwapRateHelper(RateHelper):
    r"""Proxy of C++ ConstNotionalCrossCurrencyBasisSwapRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, basis, tenor, fixingDays, calendar, convention, endOfMonth, baseCurrencyIndex, quoteCurrencyIndex, collateralCurve, isFxBaseCurrencyCollateralCurrency, isBasisOnFxBaseCurrencyLeg):
        r"""__init__(ConstNotionalCrossCurrencyBasisSwapRateHelper self, QuoteHandle basis, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< IborIndex > baseCurrencyIndex, ext::shared_ptr< IborIndex > quoteCurrencyIndex, YieldTermStructureHandle collateralCurve, bool isFxBaseCurrencyCollateralCurrency, bool isBasisOnFxBaseCurrencyLeg) -> ConstNotionalCrossCurrencyBasisSwapRateHelper"""
        _QuantLib.ConstNotionalCrossCurrencyBasisSwapRateHelper_swiginit(self, _QuantLib.new_ConstNotionalCrossCurrencyBasisSwapRateHelper(basis, tenor, fixingDays, calendar, convention, endOfMonth, baseCurrencyIndex, quoteCurrencyIndex, collateralCurve, isFxBaseCurrencyCollateralCurrency, isBasisOnFxBaseCurrencyLeg))
    __swig_destroy__ = _QuantLib.delete_ConstNotionalCrossCurrencyBasisSwapRateHelper

# Register ConstNotionalCrossCurrencyBasisSwapRateHelper in _QuantLib:
_QuantLib.ConstNotionalCrossCurrencyBasisSwapRateHelper_swigregister(ConstNotionalCrossCurrencyBasisSwapRateHelper)
class MtMCrossCurrencyBasisSwapRateHelper(RateHelper):
    r"""Proxy of C++ MtMCrossCurrencyBasisSwapRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, basis, tenor, fixingDays, calendar, convention, endOfMonth, baseCurrencyIndex, quoteCurrencyIndex, collateralCurve, isFxBaseCurrencyCollateralCurrency, isBasisOnFxBaseCurrencyLeg, isFxBaseCurrencyLegResettable):
        r"""__init__(MtMCrossCurrencyBasisSwapRateHelper self, QuoteHandle basis, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< IborIndex > baseCurrencyIndex, ext::shared_ptr< IborIndex > quoteCurrencyIndex, YieldTermStructureHandle collateralCurve, bool isFxBaseCurrencyCollateralCurrency, bool isBasisOnFxBaseCurrencyLeg, bool isFxBaseCurrencyLegResettable) -> MtMCrossCurrencyBasisSwapRateHelper"""
        _QuantLib.MtMCrossCurrencyBasisSwapRateHelper_swiginit(self, _QuantLib.new_MtMCrossCurrencyBasisSwapRateHelper(basis, tenor, fixingDays, calendar, convention, endOfMonth, baseCurrencyIndex, quoteCurrencyIndex, collateralCurve, isFxBaseCurrencyCollateralCurrency, isBasisOnFxBaseCurrencyLeg, isFxBaseCurrencyLegResettable))
    __swig_destroy__ = _QuantLib.delete_MtMCrossCurrencyBasisSwapRateHelper

# Register MtMCrossCurrencyBasisSwapRateHelper in _QuantLib:
_QuantLib.MtMCrossCurrencyBasisSwapRateHelper_swigregister(MtMCrossCurrencyBasisSwapRateHelper)
class IborIborBasisSwapRateHelper(RateHelper):
    r"""Proxy of C++ IborIborBasisSwapRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, basis, tenor, settlementDays, calendar, convention, endOfMonth, baseIndex, otherIndex, discountHandle, bootstrapBaseCurve):
        r"""__init__(IborIborBasisSwapRateHelper self, QuoteHandle basis, Period tenor, Natural settlementDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< IborIndex > const & baseIndex, ext::shared_ptr< IborIndex > const & otherIndex, YieldTermStructureHandle discountHandle, bool bootstrapBaseCurve) -> IborIborBasisSwapRateHelper"""
        _QuantLib.IborIborBasisSwapRateHelper_swiginit(self, _QuantLib.new_IborIborBasisSwapRateHelper(basis, tenor, settlementDays, calendar, convention, endOfMonth, baseIndex, otherIndex, discountHandle, bootstrapBaseCurve))
    __swig_destroy__ = _QuantLib.delete_IborIborBasisSwapRateHelper

# Register IborIborBasisSwapRateHelper in _QuantLib:
_QuantLib.IborIborBasisSwapRateHelper_swigregister(IborIborBasisSwapRateHelper)
class OvernightIborBasisSwapRateHelper(RateHelper):
    r"""Proxy of C++ OvernightIborBasisSwapRateHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(OvernightIborBasisSwapRateHelper self, QuoteHandle basis, Period tenor, Natural settlementDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< OvernightIndex > const & baseIndex, ext::shared_ptr< IborIndex > const & otherIndex, YieldTermStructureHandle discountHandle=Handle< YieldTermStructure >()) -> OvernightIborBasisSwapRateHelper"""
        _QuantLib.OvernightIborBasisSwapRateHelper_swiginit(self, _QuantLib.new_OvernightIborBasisSwapRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_OvernightIborBasisSwapRateHelper

# Register OvernightIborBasisSwapRateHelper in _QuantLib:
_QuantLib.OvernightIborBasisSwapRateHelper_swigregister(OvernightIborBasisSwapRateHelper)
class RateHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< RateHelper > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(RateHelperVector self) -> SwigPyIterator"""
        return _QuantLib.RateHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(RateHelperVector self) -> bool"""
        return _QuantLib.RateHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(RateHelperVector self) -> bool"""
        return _QuantLib.RateHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::size_type"""
        return _QuantLib.RateHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j) -> RateHelperVector"""
        return _QuantLib.RateHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j)
        __setslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j, RateHelperVector v)
        """
        return _QuantLib.RateHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j)"""
        return _QuantLib.RateHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i)
        __delitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.RateHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice) -> RateHelperVector
        __getitem__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i) -> std::vector< ext::shared_ptr< RateHelper > >::value_type const &
        """
        return _QuantLib.RateHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice, RateHelperVector v)
        __setitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)
        """
        return _QuantLib.RateHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::value_type"""
        return _QuantLib.RateHelperVector_pop(self)

    def append(self, x):
        r"""append(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)"""
        return _QuantLib.RateHelperVector_append(self, x)

    def empty(self):
        r"""empty(RateHelperVector self) -> bool"""
        return _QuantLib.RateHelperVector_empty(self)

    def size(self):
        r"""size(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::size_type"""
        return _QuantLib.RateHelperVector_size(self)

    def swap(self, v):
        r"""swap(RateHelperVector self, RateHelperVector v)"""
        return _QuantLib.RateHelperVector_swap(self, v)

    def begin(self):
        r"""begin(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::iterator"""
        return _QuantLib.RateHelperVector_begin(self)

    def end(self):
        r"""end(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::iterator"""
        return _QuantLib.RateHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator"""
        return _QuantLib.RateHelperVector_rbegin(self)

    def rend(self):
        r"""rend(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator"""
        return _QuantLib.RateHelperVector_rend(self)

    def clear(self):
        r"""clear(RateHelperVector self)"""
        return _QuantLib.RateHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::allocator_type"""
        return _QuantLib.RateHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(RateHelperVector self)"""
        return _QuantLib.RateHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator pos) -> std::vector< ext::shared_ptr< RateHelper > >::iterator
        erase(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator first, std::vector< ext::shared_ptr< RateHelper > >::iterator last) -> std::vector< ext::shared_ptr< RateHelper > >::iterator
        """
        return _QuantLib.RateHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(RateHelperVector self) -> RateHelperVector
        __init__(RateHelperVector self, RateHelperVector other) -> RateHelperVector
        __init__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type size) -> RateHelperVector
        __init__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type size, std::vector< ext::shared_ptr< RateHelper > >::value_type const & value) -> RateHelperVector
        """
        _QuantLib.RateHelperVector_swiginit(self, _QuantLib.new_RateHelperVector(*args))

    def push_back(self, x):
        r"""push_back(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)"""
        return _QuantLib.RateHelperVector_push_back(self, x)

    def front(self):
        r"""front(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::value_type const &"""
        return _QuantLib.RateHelperVector_front(self)

    def back(self):
        r"""back(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::value_type const &"""
        return _QuantLib.RateHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type n, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)"""
        return _QuantLib.RateHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type new_size)
        resize(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type new_size, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)
        """
        return _QuantLib.RateHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator pos, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< RateHelper > >::iterator
        insert(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator pos, std::vector< ext::shared_ptr< RateHelper > >::size_type n, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)
        """
        return _QuantLib.RateHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type n)"""
        return _QuantLib.RateHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::size_type"""
        return _QuantLib.RateHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RateHelperVector

# Register RateHelperVector in _QuantLib:
_QuantLib.RateHelperVector_swigregister(RateHelperVector)
class BondHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< BondHelper > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(BondHelperVector self) -> SwigPyIterator"""
        return _QuantLib.BondHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(BondHelperVector self) -> bool"""
        return _QuantLib.BondHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(BondHelperVector self) -> bool"""
        return _QuantLib.BondHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::size_type"""
        return _QuantLib.BondHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j) -> BondHelperVector"""
        return _QuantLib.BondHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j)
        __setslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j, BondHelperVector v)
        """
        return _QuantLib.BondHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j)"""
        return _QuantLib.BondHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i)
        __delitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.BondHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice) -> BondHelperVector
        __getitem__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i) -> std::vector< ext::shared_ptr< BondHelper > >::value_type const &
        """
        return _QuantLib.BondHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice, BondHelperVector v)
        __setitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)
        """
        return _QuantLib.BondHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::value_type"""
        return _QuantLib.BondHelperVector_pop(self)

    def append(self, x):
        r"""append(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)"""
        return _QuantLib.BondHelperVector_append(self, x)

    def empty(self):
        r"""empty(BondHelperVector self) -> bool"""
        return _QuantLib.BondHelperVector_empty(self)

    def size(self):
        r"""size(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::size_type"""
        return _QuantLib.BondHelperVector_size(self)

    def swap(self, v):
        r"""swap(BondHelperVector self, BondHelperVector v)"""
        return _QuantLib.BondHelperVector_swap(self, v)

    def begin(self):
        r"""begin(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::iterator"""
        return _QuantLib.BondHelperVector_begin(self)

    def end(self):
        r"""end(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::iterator"""
        return _QuantLib.BondHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator"""
        return _QuantLib.BondHelperVector_rbegin(self)

    def rend(self):
        r"""rend(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator"""
        return _QuantLib.BondHelperVector_rend(self)

    def clear(self):
        r"""clear(BondHelperVector self)"""
        return _QuantLib.BondHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::allocator_type"""
        return _QuantLib.BondHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(BondHelperVector self)"""
        return _QuantLib.BondHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator pos) -> std::vector< ext::shared_ptr< BondHelper > >::iterator
        erase(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator first, std::vector< ext::shared_ptr< BondHelper > >::iterator last) -> std::vector< ext::shared_ptr< BondHelper > >::iterator
        """
        return _QuantLib.BondHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(BondHelperVector self) -> BondHelperVector
        __init__(BondHelperVector self, BondHelperVector other) -> BondHelperVector
        __init__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type size) -> BondHelperVector
        __init__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type size, std::vector< ext::shared_ptr< BondHelper > >::value_type const & value) -> BondHelperVector
        """
        _QuantLib.BondHelperVector_swiginit(self, _QuantLib.new_BondHelperVector(*args))

    def push_back(self, x):
        r"""push_back(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)"""
        return _QuantLib.BondHelperVector_push_back(self, x)

    def front(self):
        r"""front(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::value_type const &"""
        return _QuantLib.BondHelperVector_front(self)

    def back(self):
        r"""back(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::value_type const &"""
        return _QuantLib.BondHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type n, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)"""
        return _QuantLib.BondHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type new_size)
        resize(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type new_size, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)
        """
        return _QuantLib.BondHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator pos, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< BondHelper > >::iterator
        insert(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator pos, std::vector< ext::shared_ptr< BondHelper > >::size_type n, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)
        """
        return _QuantLib.BondHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type n)"""
        return _QuantLib.BondHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::size_type"""
        return _QuantLib.BondHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_BondHelperVector

# Register BondHelperVector in _QuantLib:
_QuantLib.BondHelperVector_swigregister(BondHelperVector)

def as_depositratehelper(helper):
    r"""as_depositratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< DepositRateHelper > const"""
    return _QuantLib.as_depositratehelper(helper)

def as_fraratehelper(helper):
    r"""as_fraratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< FraRateHelper > const"""
    return _QuantLib.as_fraratehelper(helper)

def as_swapratehelper(helper):
    r"""as_swapratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< SwapRateHelper > const"""
    return _QuantLib.as_swapratehelper(helper)

def as_oisratehelper(helper):
    r"""as_oisratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< OISRateHelper > const"""
    return _QuantLib.as_oisratehelper(helper)

def as_constnotionalcrosscurrencybasisswapratehelper(helper):
    r"""as_constnotionalcrosscurrencybasisswapratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > const"""
    return _QuantLib.as_constnotionalcrosscurrencybasisswapratehelper(helper)

def as_mtmcrosscurrencybasisswapratehelper(helper):
    r"""as_mtmcrosscurrencybasisswapratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > const"""
    return _QuantLib.as_mtmcrosscurrencybasisswapratehelper(helper)
class Discount(object):
    r"""Proxy of C++ Discount class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(Discount self) -> Discount"""
        _QuantLib.Discount_swiginit(self, _QuantLib.new_Discount())
    __swig_destroy__ = _QuantLib.delete_Discount

# Register Discount in _QuantLib:
_QuantLib.Discount_swigregister(Discount)
class ZeroYield(object):
    r"""Proxy of C++ ZeroYield class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(ZeroYield self) -> ZeroYield"""
        _QuantLib.ZeroYield_swiginit(self, _QuantLib.new_ZeroYield())
    __swig_destroy__ = _QuantLib.delete_ZeroYield

# Register ZeroYield in _QuantLib:
_QuantLib.ZeroYield_swigregister(ZeroYield)
class ForwardRate(object):
    r"""Proxy of C++ ForwardRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(ForwardRate self) -> ForwardRate"""
        _QuantLib.ForwardRate_swiginit(self, _QuantLib.new_ForwardRate())
    __swig_destroy__ = _QuantLib.delete_ForwardRate

# Register ForwardRate in _QuantLib:
_QuantLib.ForwardRate_swigregister(ForwardRate)
class IterativeBootstrap(object):
    r"""Proxy of C++ _IterativeBootstrap class."""

    thisown = 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):
        r"""__init__(IterativeBootstrap self, doubleOrNull accuracy=Null< double >(), doubleOrNull minValue=Null< double >(), doubleOrNull maxValue=Null< double >()) -> IterativeBootstrap"""
        _QuantLib.IterativeBootstrap_swiginit(self, _QuantLib.new_IterativeBootstrap(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_IterativeBootstrap

# Register IterativeBootstrap in _QuantLib:
_QuantLib.IterativeBootstrap_swigregister(IterativeBootstrap)
class PiecewiseFlatForward(YieldTermStructure):
    r"""Proxy of C++ PiecewiseFlatForward class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseFlatForward self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseFlatForward
        __init__(PiecewiseFlatForward self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseFlatForward
        __init__(PiecewiseFlatForward self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseFlatForward
        __init__(PiecewiseFlatForward self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseFlatForward
        """
        _QuantLib.PiecewiseFlatForward_swiginit(self, _QuantLib.new_PiecewiseFlatForward(*args))

    def dates(self):
        r"""dates(PiecewiseFlatForward self) -> DateVector"""
        return _QuantLib.PiecewiseFlatForward_dates(self)

    def times(self):
        r"""times(PiecewiseFlatForward self) -> DoubleVector"""
        return _QuantLib.PiecewiseFlatForward_times(self)

    def nodes(self):
        r"""nodes(PiecewiseFlatForward self) -> NodeVector"""
        return _QuantLib.PiecewiseFlatForward_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseFlatForward self)"""
        return _QuantLib.PiecewiseFlatForward_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseFlatForward self)"""
        return _QuantLib.PiecewiseFlatForward_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseFlatForward self)"""
        return _QuantLib.PiecewiseFlatForward_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseFlatForward

# Register PiecewiseFlatForward in _QuantLib:
_QuantLib.PiecewiseFlatForward_swigregister(PiecewiseFlatForward)
class PiecewiseLogLinearDiscount(YieldTermStructure):
    r"""Proxy of C++ PiecewiseLogLinearDiscount class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseLogLinearDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), LogLinear i=LogLinear(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLogLinearDiscount
        __init__(PiecewiseLogLinearDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), LogLinear i=LogLinear(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLogLinearDiscount
        __init__(PiecewiseLogLinearDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLogLinearDiscount
        __init__(PiecewiseLogLinearDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLogLinearDiscount
        """
        _QuantLib.PiecewiseLogLinearDiscount_swiginit(self, _QuantLib.new_PiecewiseLogLinearDiscount(*args))

    def dates(self):
        r"""dates(PiecewiseLogLinearDiscount self) -> DateVector"""
        return _QuantLib.PiecewiseLogLinearDiscount_dates(self)

    def times(self):
        r"""times(PiecewiseLogLinearDiscount self) -> DoubleVector"""
        return _QuantLib.PiecewiseLogLinearDiscount_times(self)

    def nodes(self):
        r"""nodes(PiecewiseLogLinearDiscount self) -> NodeVector"""
        return _QuantLib.PiecewiseLogLinearDiscount_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseLogLinearDiscount self)"""
        return _QuantLib.PiecewiseLogLinearDiscount_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseLogLinearDiscount self)"""
        return _QuantLib.PiecewiseLogLinearDiscount_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseLogLinearDiscount self)"""
        return _QuantLib.PiecewiseLogLinearDiscount_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLogLinearDiscount

# Register PiecewiseLogLinearDiscount in _QuantLib:
_QuantLib.PiecewiseLogLinearDiscount_swigregister(PiecewiseLogLinearDiscount)
class PiecewiseLinearForward(YieldTermStructure):
    r"""Proxy of C++ PiecewiseLinearForward class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseLinearForward self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLinearForward
        __init__(PiecewiseLinearForward self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLinearForward
        __init__(PiecewiseLinearForward self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLinearForward
        __init__(PiecewiseLinearForward self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLinearForward
        """
        _QuantLib.PiecewiseLinearForward_swiginit(self, _QuantLib.new_PiecewiseLinearForward(*args))

    def dates(self):
        r"""dates(PiecewiseLinearForward self) -> DateVector"""
        return _QuantLib.PiecewiseLinearForward_dates(self)

    def times(self):
        r"""times(PiecewiseLinearForward self) -> DoubleVector"""
        return _QuantLib.PiecewiseLinearForward_times(self)

    def nodes(self):
        r"""nodes(PiecewiseLinearForward self) -> NodeVector"""
        return _QuantLib.PiecewiseLinearForward_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseLinearForward self)"""
        return _QuantLib.PiecewiseLinearForward_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseLinearForward self)"""
        return _QuantLib.PiecewiseLinearForward_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseLinearForward self)"""
        return _QuantLib.PiecewiseLinearForward_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLinearForward

# Register PiecewiseLinearForward in _QuantLib:
_QuantLib.PiecewiseLinearForward_swigregister(PiecewiseLinearForward)
class PiecewiseLinearZero(YieldTermStructure):
    r"""Proxy of C++ PiecewiseLinearZero class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseLinearZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLinearZero
        __init__(PiecewiseLinearZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLinearZero
        __init__(PiecewiseLinearZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLinearZero
        __init__(PiecewiseLinearZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLinearZero
        """
        _QuantLib.PiecewiseLinearZero_swiginit(self, _QuantLib.new_PiecewiseLinearZero(*args))

    def dates(self):
        r"""dates(PiecewiseLinearZero self) -> DateVector"""
        return _QuantLib.PiecewiseLinearZero_dates(self)

    def times(self):
        r"""times(PiecewiseLinearZero self) -> DoubleVector"""
        return _QuantLib.PiecewiseLinearZero_times(self)

    def nodes(self):
        r"""nodes(PiecewiseLinearZero self) -> NodeVector"""
        return _QuantLib.PiecewiseLinearZero_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseLinearZero self)"""
        return _QuantLib.PiecewiseLinearZero_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseLinearZero self)"""
        return _QuantLib.PiecewiseLinearZero_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseLinearZero self)"""
        return _QuantLib.PiecewiseLinearZero_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLinearZero

# Register PiecewiseLinearZero in _QuantLib:
_QuantLib.PiecewiseLinearZero_swigregister(PiecewiseLinearZero)
class PiecewiseCubicZero(YieldTermStructure):
    r"""Proxy of C++ PiecewiseCubicZero class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseCubicZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Cubic i=Cubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseCubicZero
        __init__(PiecewiseCubicZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Cubic i=Cubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseCubicZero
        __init__(PiecewiseCubicZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseCubicZero
        __init__(PiecewiseCubicZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseCubicZero
        """
        _QuantLib.PiecewiseCubicZero_swiginit(self, _QuantLib.new_PiecewiseCubicZero(*args))

    def dates(self):
        r"""dates(PiecewiseCubicZero self) -> DateVector"""
        return _QuantLib.PiecewiseCubicZero_dates(self)

    def times(self):
        r"""times(PiecewiseCubicZero self) -> DoubleVector"""
        return _QuantLib.PiecewiseCubicZero_times(self)

    def nodes(self):
        r"""nodes(PiecewiseCubicZero self) -> NodeVector"""
        return _QuantLib.PiecewiseCubicZero_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseCubicZero self)"""
        return _QuantLib.PiecewiseCubicZero_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseCubicZero self)"""
        return _QuantLib.PiecewiseCubicZero_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseCubicZero self)"""
        return _QuantLib.PiecewiseCubicZero_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseCubicZero

# Register PiecewiseCubicZero in _QuantLib:
_QuantLib.PiecewiseCubicZero_swigregister(PiecewiseCubicZero)
class PiecewiseLogCubicDiscount(YieldTermStructure):
    r"""Proxy of C++ PiecewiseLogCubicDiscount class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseLogCubicDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), MonotonicLogCubic i=MonotonicLogCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLogCubicDiscount
        __init__(PiecewiseLogCubicDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), MonotonicLogCubic i=MonotonicLogCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseLogCubicDiscount
        __init__(PiecewiseLogCubicDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLogCubicDiscount
        __init__(PiecewiseLogCubicDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseLogCubicDiscount
        """
        _QuantLib.PiecewiseLogCubicDiscount_swiginit(self, _QuantLib.new_PiecewiseLogCubicDiscount(*args))

    def dates(self):
        r"""dates(PiecewiseLogCubicDiscount self) -> DateVector"""
        return _QuantLib.PiecewiseLogCubicDiscount_dates(self)

    def times(self):
        r"""times(PiecewiseLogCubicDiscount self) -> DoubleVector"""
        return _QuantLib.PiecewiseLogCubicDiscount_times(self)

    def nodes(self):
        r"""nodes(PiecewiseLogCubicDiscount self) -> NodeVector"""
        return _QuantLib.PiecewiseLogCubicDiscount_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseLogCubicDiscount self)"""
        return _QuantLib.PiecewiseLogCubicDiscount_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseLogCubicDiscount self)"""
        return _QuantLib.PiecewiseLogCubicDiscount_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseLogCubicDiscount self)"""
        return _QuantLib.PiecewiseLogCubicDiscount_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLogCubicDiscount

# Register PiecewiseLogCubicDiscount in _QuantLib:
_QuantLib.PiecewiseLogCubicDiscount_swigregister(PiecewiseLogCubicDiscount)
class PiecewiseSplineCubicDiscount(YieldTermStructure):
    r"""Proxy of C++ PiecewiseSplineCubicDiscount class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseSplineCubicDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseSplineCubicDiscount
        __init__(PiecewiseSplineCubicDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseSplineCubicDiscount
        __init__(PiecewiseSplineCubicDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseSplineCubicDiscount
        __init__(PiecewiseSplineCubicDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseSplineCubicDiscount
        """
        _QuantLib.PiecewiseSplineCubicDiscount_swiginit(self, _QuantLib.new_PiecewiseSplineCubicDiscount(*args))

    def dates(self):
        r"""dates(PiecewiseSplineCubicDiscount self) -> DateVector"""
        return _QuantLib.PiecewiseSplineCubicDiscount_dates(self)

    def times(self):
        r"""times(PiecewiseSplineCubicDiscount self) -> DoubleVector"""
        return _QuantLib.PiecewiseSplineCubicDiscount_times(self)

    def nodes(self):
        r"""nodes(PiecewiseSplineCubicDiscount self) -> NodeVector"""
        return _QuantLib.PiecewiseSplineCubicDiscount_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseSplineCubicDiscount self)"""
        return _QuantLib.PiecewiseSplineCubicDiscount_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseSplineCubicDiscount self)"""
        return _QuantLib.PiecewiseSplineCubicDiscount_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseSplineCubicDiscount self)"""
        return _QuantLib.PiecewiseSplineCubicDiscount_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseSplineCubicDiscount

# Register PiecewiseSplineCubicDiscount in _QuantLib:
_QuantLib.PiecewiseSplineCubicDiscount_swigregister(PiecewiseSplineCubicDiscount)
class PiecewiseKrugerZero(YieldTermStructure):
    r"""Proxy of C++ PiecewiseKrugerZero class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseKrugerZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Kruger i=Kruger(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseKrugerZero
        __init__(PiecewiseKrugerZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Kruger i=Kruger(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseKrugerZero
        __init__(PiecewiseKrugerZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseKrugerZero
        __init__(PiecewiseKrugerZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseKrugerZero
        """
        _QuantLib.PiecewiseKrugerZero_swiginit(self, _QuantLib.new_PiecewiseKrugerZero(*args))

    def dates(self):
        r"""dates(PiecewiseKrugerZero self) -> DateVector"""
        return _QuantLib.PiecewiseKrugerZero_dates(self)

    def times(self):
        r"""times(PiecewiseKrugerZero self) -> DoubleVector"""
        return _QuantLib.PiecewiseKrugerZero_times(self)

    def nodes(self):
        r"""nodes(PiecewiseKrugerZero self) -> NodeVector"""
        return _QuantLib.PiecewiseKrugerZero_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseKrugerZero self)"""
        return _QuantLib.PiecewiseKrugerZero_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseKrugerZero self)"""
        return _QuantLib.PiecewiseKrugerZero_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseKrugerZero self)"""
        return _QuantLib.PiecewiseKrugerZero_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseKrugerZero

# Register PiecewiseKrugerZero in _QuantLib:
_QuantLib.PiecewiseKrugerZero_swigregister(PiecewiseKrugerZero)
class PiecewiseKrugerLogDiscount(YieldTermStructure):
    r"""Proxy of C++ PiecewiseKrugerLogDiscount class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseKrugerLogDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), KrugerLog i=KrugerLog(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseKrugerLogDiscount
        __init__(PiecewiseKrugerLogDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), KrugerLog i=KrugerLog(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseKrugerLogDiscount
        __init__(PiecewiseKrugerLogDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseKrugerLogDiscount
        __init__(PiecewiseKrugerLogDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseKrugerLogDiscount
        """
        _QuantLib.PiecewiseKrugerLogDiscount_swiginit(self, _QuantLib.new_PiecewiseKrugerLogDiscount(*args))

    def dates(self):
        r"""dates(PiecewiseKrugerLogDiscount self) -> DateVector"""
        return _QuantLib.PiecewiseKrugerLogDiscount_dates(self)

    def times(self):
        r"""times(PiecewiseKrugerLogDiscount self) -> DoubleVector"""
        return _QuantLib.PiecewiseKrugerLogDiscount_times(self)

    def nodes(self):
        r"""nodes(PiecewiseKrugerLogDiscount self) -> NodeVector"""
        return _QuantLib.PiecewiseKrugerLogDiscount_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseKrugerLogDiscount self)"""
        return _QuantLib.PiecewiseKrugerLogDiscount_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseKrugerLogDiscount self)"""
        return _QuantLib.PiecewiseKrugerLogDiscount_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseKrugerLogDiscount self)"""
        return _QuantLib.PiecewiseKrugerLogDiscount_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseKrugerLogDiscount

# Register PiecewiseKrugerLogDiscount in _QuantLib:
_QuantLib.PiecewiseKrugerLogDiscount_swigregister(PiecewiseKrugerLogDiscount)
class PiecewiseConvexMonotoneZero(YieldTermStructure):
    r"""Proxy of C++ PiecewiseConvexMonotoneZero class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseConvexMonotoneZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), ConvexMonotone i=ConvexMonotone(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseConvexMonotoneZero
        __init__(PiecewiseConvexMonotoneZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), ConvexMonotone i=ConvexMonotone(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseConvexMonotoneZero
        __init__(PiecewiseConvexMonotoneZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseConvexMonotoneZero
        __init__(PiecewiseConvexMonotoneZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseConvexMonotoneZero
        """
        _QuantLib.PiecewiseConvexMonotoneZero_swiginit(self, _QuantLib.new_PiecewiseConvexMonotoneZero(*args))

    def dates(self):
        r"""dates(PiecewiseConvexMonotoneZero self) -> DateVector"""
        return _QuantLib.PiecewiseConvexMonotoneZero_dates(self)

    def times(self):
        r"""times(PiecewiseConvexMonotoneZero self) -> DoubleVector"""
        return _QuantLib.PiecewiseConvexMonotoneZero_times(self)

    def nodes(self):
        r"""nodes(PiecewiseConvexMonotoneZero self) -> NodeVector"""
        return _QuantLib.PiecewiseConvexMonotoneZero_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseConvexMonotoneZero self)"""
        return _QuantLib.PiecewiseConvexMonotoneZero_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseConvexMonotoneZero self)"""
        return _QuantLib.PiecewiseConvexMonotoneZero_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseConvexMonotoneZero self)"""
        return _QuantLib.PiecewiseConvexMonotoneZero_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseConvexMonotoneZero

# Register PiecewiseConvexMonotoneZero in _QuantLib:
_QuantLib.PiecewiseConvexMonotoneZero_swigregister(PiecewiseConvexMonotoneZero)
class PiecewiseNaturalCubicZero(YieldTermStructure):
    r"""Proxy of C++ PiecewiseNaturalCubicZero class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseNaturalCubicZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseNaturalCubicZero
        __init__(PiecewiseNaturalCubicZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseNaturalCubicZero
        __init__(PiecewiseNaturalCubicZero self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseNaturalCubicZero
        __init__(PiecewiseNaturalCubicZero self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseNaturalCubicZero
        """
        _QuantLib.PiecewiseNaturalCubicZero_swiginit(self, _QuantLib.new_PiecewiseNaturalCubicZero(*args))

    def dates(self):
        r"""dates(PiecewiseNaturalCubicZero self) -> DateVector"""
        return _QuantLib.PiecewiseNaturalCubicZero_dates(self)

    def times(self):
        r"""times(PiecewiseNaturalCubicZero self) -> DoubleVector"""
        return _QuantLib.PiecewiseNaturalCubicZero_times(self)

    def nodes(self):
        r"""nodes(PiecewiseNaturalCubicZero self) -> NodeVector"""
        return _QuantLib.PiecewiseNaturalCubicZero_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseNaturalCubicZero self)"""
        return _QuantLib.PiecewiseNaturalCubicZero_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseNaturalCubicZero self)"""
        return _QuantLib.PiecewiseNaturalCubicZero_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseNaturalCubicZero self)"""
        return _QuantLib.PiecewiseNaturalCubicZero_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseNaturalCubicZero

# Register PiecewiseNaturalCubicZero in _QuantLib:
_QuantLib.PiecewiseNaturalCubicZero_swigregister(PiecewiseNaturalCubicZero)
class PiecewiseNaturalLogCubicDiscount(YieldTermStructure):
    r"""Proxy of C++ PiecewiseNaturalLogCubicDiscount class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseNaturalLogCubicDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineLogCubic i=SplineLogCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseNaturalLogCubicDiscount
        __init__(PiecewiseNaturalLogCubicDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineLogCubic i=SplineLogCubic(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseNaturalLogCubicDiscount
        __init__(PiecewiseNaturalLogCubicDiscount self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseNaturalLogCubicDiscount
        __init__(PiecewiseNaturalLogCubicDiscount self, Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseNaturalLogCubicDiscount
        """
        _QuantLib.PiecewiseNaturalLogCubicDiscount_swiginit(self, _QuantLib.new_PiecewiseNaturalLogCubicDiscount(*args))

    def dates(self):
        r"""dates(PiecewiseNaturalLogCubicDiscount self) -> DateVector"""
        return _QuantLib.PiecewiseNaturalLogCubicDiscount_dates(self)

    def times(self):
        r"""times(PiecewiseNaturalLogCubicDiscount self) -> DoubleVector"""
        return _QuantLib.PiecewiseNaturalLogCubicDiscount_times(self)

    def nodes(self):
        r"""nodes(PiecewiseNaturalLogCubicDiscount self) -> NodeVector"""
        return _QuantLib.PiecewiseNaturalLogCubicDiscount_nodes(self)

    def recalculate(self):
        r"""recalculate(PiecewiseNaturalLogCubicDiscount self)"""
        return _QuantLib.PiecewiseNaturalLogCubicDiscount_recalculate(self)

    def freeze(self):
        r"""freeze(PiecewiseNaturalLogCubicDiscount self)"""
        return _QuantLib.PiecewiseNaturalLogCubicDiscount_freeze(self)

    def unfreeze(self):
        r"""unfreeze(PiecewiseNaturalLogCubicDiscount self)"""
        return _QuantLib.PiecewiseNaturalLogCubicDiscount_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseNaturalLogCubicDiscount

# Register PiecewiseNaturalLogCubicDiscount in _QuantLib:
_QuantLib.PiecewiseNaturalLogCubicDiscount_swigregister(PiecewiseNaturalLogCubicDiscount)
class GlobalBootstrap(object):
    r"""Proxy of C++ _GlobalBootstrap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(GlobalBootstrap self, doubleOrNull accuracy=Null< double >()) -> GlobalBootstrap
        __init__(GlobalBootstrap self, RateHelperVector additionalHelpers, DateVector additionalDates, doubleOrNull accuracy=Null< double >()) -> GlobalBootstrap
        """
        _QuantLib.GlobalBootstrap_swiginit(self, _QuantLib.new_GlobalBootstrap(*args))
    __swig_destroy__ = _QuantLib.delete_GlobalBootstrap

# Register GlobalBootstrap in _QuantLib:
_QuantLib.GlobalBootstrap_swigregister(GlobalBootstrap)
class GlobalLinearSimpleZeroCurve(YieldTermStructure):
    r"""Proxy of C++ GlobalLinearSimpleZeroCurve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, referenceDate, instruments, dayCounter, b):
        r"""__init__(GlobalLinearSimpleZeroCurve self, Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, GlobalBootstrap b) -> GlobalLinearSimpleZeroCurve"""
        _QuantLib.GlobalLinearSimpleZeroCurve_swiginit(self, _QuantLib.new_GlobalLinearSimpleZeroCurve(referenceDate, instruments, dayCounter, b))

    def dates(self):
        r"""dates(GlobalLinearSimpleZeroCurve self) -> DateVector"""
        return _QuantLib.GlobalLinearSimpleZeroCurve_dates(self)

    def times(self):
        r"""times(GlobalLinearSimpleZeroCurve self) -> DoubleVector"""
        return _QuantLib.GlobalLinearSimpleZeroCurve_times(self)

    def nodes(self):
        r"""nodes(GlobalLinearSimpleZeroCurve self) -> NodeVector"""
        return _QuantLib.GlobalLinearSimpleZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_GlobalLinearSimpleZeroCurve

# Register GlobalLinearSimpleZeroCurve in _QuantLib:
_QuantLib.GlobalLinearSimpleZeroCurve_swigregister(GlobalLinearSimpleZeroCurve)
class DefaultProbabilityTermStructure(TermStructure):
    r"""Proxy of C++ DefaultProbabilityTermStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def defaultProbability(self, *args):
        r"""
        defaultProbability(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Probability
        defaultProbability(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Probability
        defaultProbability(DefaultProbabilityTermStructure self, Date arg2, Date arg3, bool extrapolate=False) -> Probability
        defaultProbability(DefaultProbabilityTermStructure self, Time arg2, Time arg3, bool extrapolate=False) -> Probability
        """
        return _QuantLib.DefaultProbabilityTermStructure_defaultProbability(self, *args)

    def survivalProbability(self, *args):
        r"""
        survivalProbability(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Probability
        survivalProbability(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Probability
        """
        return _QuantLib.DefaultProbabilityTermStructure_survivalProbability(self, *args)

    def defaultDensity(self, *args):
        r"""
        defaultDensity(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Real
        defaultDensity(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Real
        """
        return _QuantLib.DefaultProbabilityTermStructure_defaultDensity(self, *args)

    def hazardRate(self, *args):
        r"""
        hazardRate(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Real
        hazardRate(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Real
        """
        return _QuantLib.DefaultProbabilityTermStructure_hazardRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructure

# Register DefaultProbabilityTermStructure in _QuantLib:
_QuantLib.DefaultProbabilityTermStructure_swigregister(DefaultProbabilityTermStructure)
class DefaultProbabilityTermStructureHandle(object):
    r"""Proxy of C++ Handle< DefaultProbabilityTermStructure > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DefaultProbabilityTermStructureHandle self, ext::shared_ptr< DefaultProbabilityTermStructure > const & arg2=ext::shared_ptr()) -> DefaultProbabilityTermStructureHandle"""
        _QuantLib.DefaultProbabilityTermStructureHandle_swiginit(self, _QuantLib.new_DefaultProbabilityTermStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(DefaultProbabilityTermStructureHandle self) -> ext::shared_ptr< DefaultProbabilityTermStructure >"""
        return _QuantLib.DefaultProbabilityTermStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(DefaultProbabilityTermStructureHandle self) -> ext::shared_ptr< DefaultProbabilityTermStructure >"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(DefaultProbabilityTermStructureHandle self) -> bool"""
        return _QuantLib.DefaultProbabilityTermStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DefaultProbabilityTermStructureHandle self) -> bool"""
        return _QuantLib.DefaultProbabilityTermStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(DefaultProbabilityTermStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructureHandle

    def defaultProbability(self, *args):
        r"""
        defaultProbability(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Probability
        defaultProbability(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Probability
        defaultProbability(DefaultProbabilityTermStructureHandle self, Date arg2, Date arg3, bool extrapolate=False) -> Probability
        defaultProbability(DefaultProbabilityTermStructureHandle self, Time arg2, Time arg3, bool extrapolate=False) -> Probability
        """
        return _QuantLib.DefaultProbabilityTermStructureHandle_defaultProbability(self, *args)

    def survivalProbability(self, *args):
        r"""
        survivalProbability(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Probability
        survivalProbability(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Probability
        """
        return _QuantLib.DefaultProbabilityTermStructureHandle_survivalProbability(self, *args)

    def defaultDensity(self, *args):
        r"""
        defaultDensity(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Real
        defaultDensity(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Real
        """
        return _QuantLib.DefaultProbabilityTermStructureHandle_defaultDensity(self, *args)

    def hazardRate(self, *args):
        r"""
        hazardRate(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Real
        hazardRate(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Real
        """
        return _QuantLib.DefaultProbabilityTermStructureHandle_hazardRate(self, *args)

    def dayCounter(self):
        r"""dayCounter(DefaultProbabilityTermStructureHandle self) -> DayCounter"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(DefaultProbabilityTermStructureHandle self, Date date) -> Time"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(DefaultProbabilityTermStructureHandle self) -> Calendar"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(DefaultProbabilityTermStructureHandle self) -> Date"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(DefaultProbabilityTermStructureHandle self) -> Date"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(DefaultProbabilityTermStructureHandle self) -> Time"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(DefaultProbabilityTermStructureHandle self)"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(DefaultProbabilityTermStructureHandle self)"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(DefaultProbabilityTermStructureHandle self) -> bool"""
        return _QuantLib.DefaultProbabilityTermStructureHandle_allowsExtrapolation(self)

# Register DefaultProbabilityTermStructureHandle in _QuantLib:
_QuantLib.DefaultProbabilityTermStructureHandle_swigregister(DefaultProbabilityTermStructureHandle)
class RelinkableDefaultProbabilityTermStructureHandle(DefaultProbabilityTermStructureHandle):
    r"""Proxy of C++ RelinkableHandle< DefaultProbabilityTermStructure > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(RelinkableDefaultProbabilityTermStructureHandle self, ext::shared_ptr< DefaultProbabilityTermStructure > const & arg2=ext::shared_ptr()) -> RelinkableDefaultProbabilityTermStructureHandle"""
        _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableDefaultProbabilityTermStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableDefaultProbabilityTermStructureHandle self, ext::shared_ptr< DefaultProbabilityTermStructure > const & arg2)"""
        return _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableDefaultProbabilityTermStructureHandle self)"""
        return _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableDefaultProbabilityTermStructureHandle

# Register RelinkableDefaultProbabilityTermStructureHandle in _QuantLib:
_QuantLib.RelinkableDefaultProbabilityTermStructureHandle_swigregister(RelinkableDefaultProbabilityTermStructureHandle)
class FlatHazardRate(DefaultProbabilityTermStructure):
    r"""Proxy of C++ FlatHazardRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FlatHazardRate self, Integer settlementDays, Calendar calendar, QuoteHandle hazardRate, DayCounter dayCounter) -> FlatHazardRate
        __init__(FlatHazardRate self, Date todaysDate, QuoteHandle hazardRate, DayCounter dayCounter) -> FlatHazardRate
        """
        _QuantLib.FlatHazardRate_swiginit(self, _QuantLib.new_FlatHazardRate(*args))
    __swig_destroy__ = _QuantLib.delete_FlatHazardRate

# Register FlatHazardRate in _QuantLib:
_QuantLib.FlatHazardRate_swigregister(FlatHazardRate)
class HazardRateCurve(DefaultProbabilityTermStructure):
    r"""Proxy of C++ InterpolatedHazardRateCurve< BackwardFlat > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(HazardRateCurve self, DateVector dates, DoubleVector hazardRates, DayCounter dayCounter, Calendar calendar=Calendar(), BackwardFlat i=BackwardFlat()) -> HazardRateCurve"""
        _QuantLib.HazardRateCurve_swiginit(self, _QuantLib.new_HazardRateCurve(*args))

    def dates(self):
        r"""dates(HazardRateCurve self) -> DateVector"""
        return _QuantLib.HazardRateCurve_dates(self)

    def hazardRates(self):
        r"""hazardRates(HazardRateCurve self) -> DoubleVector"""
        return _QuantLib.HazardRateCurve_hazardRates(self)

    def nodes(self):
        r"""nodes(HazardRateCurve self) -> NodeVector"""
        return _QuantLib.HazardRateCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_HazardRateCurve

# Register HazardRateCurve in _QuantLib:
_QuantLib.HazardRateCurve_swigregister(HazardRateCurve)
class DefaultDensityCurve(DefaultProbabilityTermStructure):
    r"""Proxy of C++ InterpolatedDefaultDensityCurve< Linear > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DefaultDensityCurve self, DateVector dates, DoubleVector densities, DayCounter dayCounter, Calendar calendar=Calendar(), Linear i=Linear()) -> DefaultDensityCurve"""
        _QuantLib.DefaultDensityCurve_swiginit(self, _QuantLib.new_DefaultDensityCurve(*args))

    def dates(self):
        r"""dates(DefaultDensityCurve self) -> DateVector"""
        return _QuantLib.DefaultDensityCurve_dates(self)

    def defaultDensities(self):
        r"""defaultDensities(DefaultDensityCurve self) -> DoubleVector"""
        return _QuantLib.DefaultDensityCurve_defaultDensities(self)

    def nodes(self):
        r"""nodes(DefaultDensityCurve self) -> NodeVector"""
        return _QuantLib.DefaultDensityCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_DefaultDensityCurve

# Register DefaultDensityCurve in _QuantLib:
_QuantLib.DefaultDensityCurve_swigregister(DefaultDensityCurve)
class SurvivalProbabilityCurve(DefaultProbabilityTermStructure):
    r"""Proxy of C++ InterpolatedSurvivalProbabilityCurve< Linear > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(SurvivalProbabilityCurve self, DateVector dates, DoubleVector probabilities, DayCounter dayCounter, Calendar calendar=Calendar(), Linear i=Linear()) -> SurvivalProbabilityCurve"""
        _QuantLib.SurvivalProbabilityCurve_swiginit(self, _QuantLib.new_SurvivalProbabilityCurve(*args))

    def dates(self):
        r"""dates(SurvivalProbabilityCurve self) -> DateVector"""
        return _QuantLib.SurvivalProbabilityCurve_dates(self)

    def survivalProbabilities(self):
        r"""survivalProbabilities(SurvivalProbabilityCurve self) -> DoubleVector"""
        return _QuantLib.SurvivalProbabilityCurve_survivalProbabilities(self)

    def nodes(self):
        r"""nodes(SurvivalProbabilityCurve self) -> NodeVector"""
        return _QuantLib.SurvivalProbabilityCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_SurvivalProbabilityCurve

# Register SurvivalProbabilityCurve in _QuantLib:
_QuantLib.SurvivalProbabilityCurve_swigregister(SurvivalProbabilityCurve)
class DefaultProbabilityHelper(Observable):
    r"""Proxy of C++ DefaultProbabilityHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def quote(self):
        r"""quote(DefaultProbabilityHelper self) -> QuoteHandle"""
        return _QuantLib.DefaultProbabilityHelper_quote(self)

    def latestDate(self):
        r"""latestDate(DefaultProbabilityHelper self) -> Date"""
        return _QuantLib.DefaultProbabilityHelper_latestDate(self)

    def earliestDate(self):
        r"""earliestDate(DefaultProbabilityHelper self) -> Date"""
        return _QuantLib.DefaultProbabilityHelper_earliestDate(self)

    def maturityDate(self):
        r"""maturityDate(DefaultProbabilityHelper self) -> Date"""
        return _QuantLib.DefaultProbabilityHelper_maturityDate(self)

    def latestRelevantDate(self):
        r"""latestRelevantDate(DefaultProbabilityHelper self) -> Date"""
        return _QuantLib.DefaultProbabilityHelper_latestRelevantDate(self)

    def pillarDate(self):
        r"""pillarDate(DefaultProbabilityHelper self) -> Date"""
        return _QuantLib.DefaultProbabilityHelper_pillarDate(self)

    def impliedQuote(self):
        r"""impliedQuote(DefaultProbabilityHelper self) -> Real"""
        return _QuantLib.DefaultProbabilityHelper_impliedQuote(self)

    def quoteError(self):
        r"""quoteError(DefaultProbabilityHelper self) -> Real"""
        return _QuantLib.DefaultProbabilityHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelper

# Register DefaultProbabilityHelper in _QuantLib:
_QuantLib.DefaultProbabilityHelper_swigregister(DefaultProbabilityHelper)
class DefaultProbabilityHelperVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< DefaultProbabilityHelper > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(DefaultProbabilityHelperVector self) -> SwigPyIterator"""
        return _QuantLib.DefaultProbabilityHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DefaultProbabilityHelperVector self) -> bool"""
        return _QuantLib.DefaultProbabilityHelperVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DefaultProbabilityHelperVector self) -> bool"""
        return _QuantLib.DefaultProbabilityHelperVector___bool__(self)

    def __len__(self):
        r"""__len__(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type"""
        return _QuantLib.DefaultProbabilityHelperVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j) -> DefaultProbabilityHelperVector"""
        return _QuantLib.DefaultProbabilityHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j)
        __setslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j, DefaultProbabilityHelperVector v)
        """
        return _QuantLib.DefaultProbabilityHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j)"""
        return _QuantLib.DefaultProbabilityHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i)
        __delitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.DefaultProbabilityHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice) -> DefaultProbabilityHelperVector
        __getitem__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &
        """
        return _QuantLib.DefaultProbabilityHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice, DefaultProbabilityHelperVector v)
        __setitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)
        """
        return _QuantLib.DefaultProbabilityHelperVector___setitem__(self, *args)

    def pop(self):
        r"""pop(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type"""
        return _QuantLib.DefaultProbabilityHelperVector_pop(self)

    def append(self, x):
        r"""append(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)"""
        return _QuantLib.DefaultProbabilityHelperVector_append(self, x)

    def empty(self):
        r"""empty(DefaultProbabilityHelperVector self) -> bool"""
        return _QuantLib.DefaultProbabilityHelperVector_empty(self)

    def size(self):
        r"""size(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type"""
        return _QuantLib.DefaultProbabilityHelperVector_size(self)

    def swap(self, v):
        r"""swap(DefaultProbabilityHelperVector self, DefaultProbabilityHelperVector v)"""
        return _QuantLib.DefaultProbabilityHelperVector_swap(self, v)

    def begin(self):
        r"""begin(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator"""
        return _QuantLib.DefaultProbabilityHelperVector_begin(self)

    def end(self):
        r"""end(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator"""
        return _QuantLib.DefaultProbabilityHelperVector_end(self)

    def rbegin(self):
        r"""rbegin(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator"""
        return _QuantLib.DefaultProbabilityHelperVector_rbegin(self)

    def rend(self):
        r"""rend(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator"""
        return _QuantLib.DefaultProbabilityHelperVector_rend(self)

    def clear(self):
        r"""clear(DefaultProbabilityHelperVector self)"""
        return _QuantLib.DefaultProbabilityHelperVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::allocator_type"""
        return _QuantLib.DefaultProbabilityHelperVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DefaultProbabilityHelperVector self)"""
        return _QuantLib.DefaultProbabilityHelperVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator
        erase(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator first, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator last) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator
        """
        return _QuantLib.DefaultProbabilityHelperVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DefaultProbabilityHelperVector self) -> DefaultProbabilityHelperVector
        __init__(DefaultProbabilityHelperVector self, DefaultProbabilityHelperVector other) -> DefaultProbabilityHelperVector
        __init__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type size) -> DefaultProbabilityHelperVector
        __init__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type size, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & value) -> DefaultProbabilityHelperVector
        """
        _QuantLib.DefaultProbabilityHelperVector_swiginit(self, _QuantLib.new_DefaultProbabilityHelperVector(*args))

    def push_back(self, x):
        r"""push_back(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)"""
        return _QuantLib.DefaultProbabilityHelperVector_push_back(self, x)

    def front(self):
        r"""front(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &"""
        return _QuantLib.DefaultProbabilityHelperVector_front(self)

    def back(self):
        r"""back(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &"""
        return _QuantLib.DefaultProbabilityHelperVector_back(self)

    def assign(self, n, x):
        r"""assign(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)"""
        return _QuantLib.DefaultProbabilityHelperVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type new_size)
        resize(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type new_size, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)
        """
        return _QuantLib.DefaultProbabilityHelperVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator
        insert(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)
        """
        return _QuantLib.DefaultProbabilityHelperVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n)"""
        return _QuantLib.DefaultProbabilityHelperVector_reserve(self, n)

    def capacity(self):
        r"""capacity(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type"""
        return _QuantLib.DefaultProbabilityHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelperVector

# Register DefaultProbabilityHelperVector in _QuantLib:
_QuantLib.DefaultProbabilityHelperVector_swigregister(DefaultProbabilityHelperVector)
class SpreadCdsHelper(DefaultProbabilityHelper):
    r"""Proxy of C++ SpreadCdsHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SpreadCdsHelper self, QuoteHandle spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint) -> SpreadCdsHelper
        __init__(SpreadCdsHelper self, Rate spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint) -> SpreadCdsHelper
        """
        _QuantLib.SpreadCdsHelper_swiginit(self, _QuantLib.new_SpreadCdsHelper(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadCdsHelper

# Register SpreadCdsHelper in _QuantLib:
_QuantLib.SpreadCdsHelper_swigregister(SpreadCdsHelper)
class UpfrontCdsHelper(DefaultProbabilityHelper):
    r"""Proxy of C++ UpfrontCdsHelper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(UpfrontCdsHelper self, QuoteHandle upfront, Rate spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, Natural upfrontSettlementDays=0, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint) -> UpfrontCdsHelper
        __init__(UpfrontCdsHelper self, Rate upfront, Rate spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, Natural upfrontSettlementDays=0, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint) -> UpfrontCdsHelper
        """
        _QuantLib.UpfrontCdsHelper_swiginit(self, _QuantLib.new_UpfrontCdsHelper(*args))
    __swig_destroy__ = _QuantLib.delete_UpfrontCdsHelper

# Register UpfrontCdsHelper in _QuantLib:
_QuantLib.UpfrontCdsHelper_swigregister(UpfrontCdsHelper)
class HazardRate(object):
    r"""Proxy of C++ HazardRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(HazardRate self) -> HazardRate"""
        _QuantLib.HazardRate_swiginit(self, _QuantLib.new_HazardRate())
    __swig_destroy__ = _QuantLib.delete_HazardRate

# Register HazardRate in _QuantLib:
_QuantLib.HazardRate_swigregister(HazardRate)
class DefaultDensity(object):
    r"""Proxy of C++ DefaultDensity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(DefaultDensity self) -> DefaultDensity"""
        _QuantLib.DefaultDensity_swiginit(self, _QuantLib.new_DefaultDensity())
    __swig_destroy__ = _QuantLib.delete_DefaultDensity

# Register DefaultDensity in _QuantLib:
_QuantLib.DefaultDensity_swigregister(DefaultDensity)
class PiecewiseFlatHazardRate(DefaultProbabilityTermStructure):
    r"""Proxy of C++ PiecewiseFlatHazardRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PiecewiseFlatHazardRate self, Date referenceDate, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseFlatHazardRate
        __init__(PiecewiseFlatHazardRate self, Integer settlementDays, Calendar calendar, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap()) -> PiecewiseFlatHazardRate
        __init__(PiecewiseFlatHazardRate self, Date referenceDate, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseFlatHazardRate
        __init__(PiecewiseFlatHazardRate self, Integer settlementDays, Calendar calendar, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseFlatHazardRate
        """
        _QuantLib.PiecewiseFlatHazardRate_swiginit(self, _QuantLib.new_PiecewiseFlatHazardRate(*args))

    def dates(self):
        r"""dates(PiecewiseFlatHazardRate self) -> DateVector"""
        return _QuantLib.PiecewiseFlatHazardRate_dates(self)

    def times(self):
        r"""times(PiecewiseFlatHazardRate self) -> DoubleVector"""
        return _QuantLib.PiecewiseFlatHazardRate_times(self)

    def nodes(self):
        r"""nodes(PiecewiseFlatHazardRate self) -> NodeVector"""
        return _QuantLib.PiecewiseFlatHazardRate_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseFlatHazardRate

# Register PiecewiseFlatHazardRate in _QuantLib:
_QuantLib.PiecewiseFlatHazardRate_swigregister(PiecewiseFlatHazardRate)
class RiskyBondEngine(PricingEngine):
    r"""Proxy of C++ RiskyBondEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, defaultCurve, recoveryRate, riskFreeCurve):
        r"""__init__(RiskyBondEngine self, DefaultProbabilityTermStructureHandle defaultCurve, Real recoveryRate, YieldTermStructureHandle riskFreeCurve) -> RiskyBondEngine"""
        _QuantLib.RiskyBondEngine_swiginit(self, _QuantLib.new_RiskyBondEngine(defaultCurve, recoveryRate, riskFreeCurve))
    __swig_destroy__ = _QuantLib.delete_RiskyBondEngine

# Register RiskyBondEngine in _QuantLib:
_QuantLib.RiskyBondEngine_swigregister(RiskyBondEngine)
class Protection(object):
    r"""Proxy of C++ Protection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Buyer = _QuantLib.Protection_Buyer
    
    Seller = _QuantLib.Protection_Seller
    

    def __init__(self):
        r"""__init__(Protection self) -> Protection"""
        _QuantLib.Protection_swiginit(self, _QuantLib.new_Protection())
    __swig_destroy__ = _QuantLib.delete_Protection

# Register Protection in _QuantLib:
_QuantLib.Protection_swigregister(Protection)
class Claim(object):
    r"""Proxy of C++ Claim class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def amount(self, defaultDate, notional, recoveryRate):
        r"""amount(Claim self, Date defaultDate, Real notional, Real recoveryRate) -> Real"""
        return _QuantLib.Claim_amount(self, defaultDate, notional, recoveryRate)
    __swig_destroy__ = _QuantLib.delete_Claim

# Register Claim in _QuantLib:
_QuantLib.Claim_swigregister(Claim)
class FaceValueClaim(Claim):
    r"""Proxy of C++ FaceValueClaim class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(FaceValueClaim self) -> FaceValueClaim"""
        _QuantLib.FaceValueClaim_swiginit(self, _QuantLib.new_FaceValueClaim())
    __swig_destroy__ = _QuantLib.delete_FaceValueClaim

# Register FaceValueClaim in _QuantLib:
_QuantLib.FaceValueClaim_swigregister(FaceValueClaim)
class FaceValueAccrualClaim(Claim):
    r"""Proxy of C++ FaceValueAccrualClaim class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, bond):
        r"""__init__(FaceValueAccrualClaim self, ext::shared_ptr< Bond > const & bond) -> FaceValueAccrualClaim"""
        _QuantLib.FaceValueAccrualClaim_swiginit(self, _QuantLib.new_FaceValueAccrualClaim(bond))
    __swig_destroy__ = _QuantLib.delete_FaceValueAccrualClaim

# Register FaceValueAccrualClaim in _QuantLib:
_QuantLib.FaceValueAccrualClaim_swigregister(FaceValueAccrualClaim)
class CreditDefaultSwap(Instrument):
    r"""Proxy of C++ CreditDefaultSwap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Midpoint = _QuantLib.CreditDefaultSwap_Midpoint
    
    ISDA = _QuantLib.CreditDefaultSwap_ISDA
    

    def __init__(self, *args):
        r"""
        __init__(CreditDefaultSwap self, Protection::Side side, Real notional, Rate spread, Schedule schedule, BusinessDayConvention paymentConvention, DayCounter dayCounter, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date protectionStart=Date(), ext::shared_ptr< Claim > const & claim={}, DayCounter lastPeriodDayCounter=DayCounter(), bool const rebatesAccrual=True, Date tradeDate=Date(), Natural cashSettlementDays=3) -> CreditDefaultSwap
        __init__(CreditDefaultSwap self, Protection::Side side, Real notional, Rate upfront, Rate spread, Schedule schedule, BusinessDayConvention paymentConvention, DayCounter dayCounter, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date protectionStart=Date(), Date upfrontDate=Date(), ext::shared_ptr< Claim > const & claim={}, DayCounter lastPeriodDayCounter=DayCounter(), bool const rebatesAccrual=True, Date tradeDate=Date(), Natural cashSettlementDays=3) -> CreditDefaultSwap
        """
        _QuantLib.CreditDefaultSwap_swiginit(self, _QuantLib.new_CreditDefaultSwap(*args))

    def side(self):
        r"""side(CreditDefaultSwap self) -> Protection::Side"""
        return _QuantLib.CreditDefaultSwap_side(self)

    def notional(self):
        r"""notional(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_notional(self)

    def runningSpread(self):
        r"""runningSpread(CreditDefaultSwap self) -> Rate"""
        return _QuantLib.CreditDefaultSwap_runningSpread(self)

    def upfront(self):
        r"""upfront(CreditDefaultSwap self) -> doubleOrNull"""
        return _QuantLib.CreditDefaultSwap_upfront(self)

    def settlesAccrual(self):
        r"""settlesAccrual(CreditDefaultSwap self) -> bool"""
        return _QuantLib.CreditDefaultSwap_settlesAccrual(self)

    def paysAtDefaultTime(self):
        r"""paysAtDefaultTime(CreditDefaultSwap self) -> bool"""
        return _QuantLib.CreditDefaultSwap_paysAtDefaultTime(self)

    def coupons(self):
        r"""coupons(CreditDefaultSwap self) -> Leg"""
        return _QuantLib.CreditDefaultSwap_coupons(self)

    def protectionStartDate(self):
        r"""protectionStartDate(CreditDefaultSwap self) -> Date"""
        return _QuantLib.CreditDefaultSwap_protectionStartDate(self)

    def protectionEndDate(self):
        r"""protectionEndDate(CreditDefaultSwap self) -> Date"""
        return _QuantLib.CreditDefaultSwap_protectionEndDate(self)

    def rebatesAccrual(self):
        r"""rebatesAccrual(CreditDefaultSwap self) -> bool"""
        return _QuantLib.CreditDefaultSwap_rebatesAccrual(self)

    def upfrontPayment(self):
        r"""upfrontPayment(CreditDefaultSwap self) -> ext::shared_ptr< CashFlow >"""
        return _QuantLib.CreditDefaultSwap_upfrontPayment(self)

    def accrualRebate(self):
        r"""accrualRebate(CreditDefaultSwap self) -> ext::shared_ptr< CashFlow >"""
        return _QuantLib.CreditDefaultSwap_accrualRebate(self)

    def tradeDate(self):
        r"""tradeDate(CreditDefaultSwap self) -> Date"""
        return _QuantLib.CreditDefaultSwap_tradeDate(self)

    def cashSettlementDays(self):
        r"""cashSettlementDays(CreditDefaultSwap self) -> Natural"""
        return _QuantLib.CreditDefaultSwap_cashSettlementDays(self)

    def fairUpfront(self):
        r"""fairUpfront(CreditDefaultSwap self) -> Rate"""
        return _QuantLib.CreditDefaultSwap_fairUpfront(self)

    def fairSpread(self):
        r"""fairSpread(CreditDefaultSwap self) -> Rate"""
        return _QuantLib.CreditDefaultSwap_fairSpread(self)

    def couponLegBPS(self):
        r"""couponLegBPS(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_couponLegBPS(self)

    def upfrontBPS(self):
        r"""upfrontBPS(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_upfrontBPS(self)

    def couponLegNPV(self):
        r"""couponLegNPV(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_couponLegNPV(self)

    def defaultLegNPV(self):
        r"""defaultLegNPV(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_defaultLegNPV(self)

    def upfrontNPV(self):
        r"""upfrontNPV(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_upfrontNPV(self)

    def accrualRebateNPV(self):
        r"""accrualRebateNPV(CreditDefaultSwap self) -> Real"""
        return _QuantLib.CreditDefaultSwap_accrualRebateNPV(self)

    def impliedHazardRate(self, *args):
        r"""impliedHazardRate(CreditDefaultSwap self, Real targetNPV, YieldTermStructureHandle discountCurve, DayCounter dayCounter, Real recoveryRate=0.4, Real accuracy=1.0e-6, CreditDefaultSwap::PricingModel model=Midpoint) -> Rate"""
        return _QuantLib.CreditDefaultSwap_impliedHazardRate(self, *args)

    def conventionalSpread(self, *args):
        r"""conventionalSpread(CreditDefaultSwap self, Real conventionalRecovery, YieldTermStructureHandle discountCurve, DayCounter dayCounter, CreditDefaultSwap::PricingModel model=Midpoint) -> Rate"""
        return _QuantLib.CreditDefaultSwap_conventionalSpread(self, *args)
    __swig_destroy__ = _QuantLib.delete_CreditDefaultSwap

# Register CreditDefaultSwap in _QuantLib:
_QuantLib.CreditDefaultSwap_swigregister(CreditDefaultSwap)
class MidPointCdsEngine(PricingEngine):
    r"""Proxy of C++ MidPointCdsEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, probability, recoveryRate, discountCurve):
        r"""__init__(MidPointCdsEngine self, DefaultProbabilityTermStructureHandle probability, Real recoveryRate, YieldTermStructureHandle discountCurve) -> MidPointCdsEngine"""
        _QuantLib.MidPointCdsEngine_swiginit(self, _QuantLib.new_MidPointCdsEngine(probability, recoveryRate, discountCurve))
    __swig_destroy__ = _QuantLib.delete_MidPointCdsEngine

# Register MidPointCdsEngine in _QuantLib:
_QuantLib.MidPointCdsEngine_swigregister(MidPointCdsEngine)
class IntegralCdsEngine(PricingEngine):
    r"""Proxy of C++ IntegralCdsEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, integrationStep, probability, recoveryRate, discountCurve, includeSettlementDateFlows=False):
        r"""__init__(IntegralCdsEngine self, Period integrationStep, DefaultProbabilityTermStructureHandle probability, Real recoveryRate, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows=False) -> IntegralCdsEngine"""
        _QuantLib.IntegralCdsEngine_swiginit(self, _QuantLib.new_IntegralCdsEngine(integrationStep, probability, recoveryRate, discountCurve, includeSettlementDateFlows))
    __swig_destroy__ = _QuantLib.delete_IntegralCdsEngine

# Register IntegralCdsEngine in _QuantLib:
_QuantLib.IntegralCdsEngine_swigregister(IntegralCdsEngine)
class IsdaCdsEngine(PricingEngine):
    r"""Proxy of C++ IsdaCdsEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoFix = _QuantLib.IsdaCdsEngine_NoFix
    
    Taylor = _QuantLib.IsdaCdsEngine_Taylor
    
    HalfDayBias = _QuantLib.IsdaCdsEngine_HalfDayBias
    
    NoBias = _QuantLib.IsdaCdsEngine_NoBias
    
    Flat = _QuantLib.IsdaCdsEngine_Flat
    
    Piecewise = _QuantLib.IsdaCdsEngine_Piecewise
    

    def __init__(self, *args):
        r"""__init__(IsdaCdsEngine self, DefaultProbabilityTermStructureHandle probability, Real recoveryRate, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows=False, IsdaCdsEngine::NumericalFix const numericalFix=Taylor, IsdaCdsEngine::AccrualBias const accrualBias=HalfDayBias, IsdaCdsEngine::ForwardsInCouponPeriod const forwardsInCouponPeriod=Piecewise) -> IsdaCdsEngine"""
        _QuantLib.IsdaCdsEngine_swiginit(self, _QuantLib.new_IsdaCdsEngine(*args))
    __swig_destroy__ = _QuantLib.delete_IsdaCdsEngine

# Register IsdaCdsEngine in _QuantLib:
_QuantLib.IsdaCdsEngine_swigregister(IsdaCdsEngine)
class CdsOption(Option):
    r"""Proxy of C++ CdsOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, swap, exercise, knocksOut=True):
        r"""__init__(CdsOption self, ext::shared_ptr< CreditDefaultSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, bool knocksOut=True) -> CdsOption"""
        _QuantLib.CdsOption_swiginit(self, _QuantLib.new_CdsOption(swap, exercise, knocksOut))

    def atmRate(self):
        r"""atmRate(CdsOption self) -> Rate"""
        return _QuantLib.CdsOption_atmRate(self)

    def riskyAnnuity(self):
        r"""riskyAnnuity(CdsOption self) -> Real"""
        return _QuantLib.CdsOption_riskyAnnuity(self)

    def impliedVolatility(self, price, termStructure, arg4, recoveryRate, accuracy=1.e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0):
        r"""impliedVolatility(CdsOption self, Real price, YieldTermStructureHandle termStructure, DefaultProbabilityTermStructureHandle arg4, Real recoveryRate, Real accuracy=1.e-4, Size maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0) -> Volatility"""
        return _QuantLib.CdsOption_impliedVolatility(self, price, termStructure, arg4, recoveryRate, accuracy, maxEvaluations, minVol, maxVol)
    __swig_destroy__ = _QuantLib.delete_CdsOption

# Register CdsOption in _QuantLib:
_QuantLib.CdsOption_swigregister(CdsOption)
class BlackCdsOptionEngine(PricingEngine):
    r"""Proxy of C++ BlackCdsOptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, recoveryRate, termStructure, vol):
        r"""__init__(BlackCdsOptionEngine self, DefaultProbabilityTermStructureHandle arg2, Real recoveryRate, YieldTermStructureHandle termStructure, QuoteHandle vol) -> BlackCdsOptionEngine"""
        _QuantLib.BlackCdsOptionEngine_swiginit(self, _QuantLib.new_BlackCdsOptionEngine(arg2, recoveryRate, termStructure, vol))

    def termStructure(self):
        r"""termStructure(BlackCdsOptionEngine self) -> YieldTermStructureHandle"""
        return _QuantLib.BlackCdsOptionEngine_termStructure(self)

    def volatility(self):
        r"""volatility(BlackCdsOptionEngine self) -> QuoteHandle"""
        return _QuantLib.BlackCdsOptionEngine_volatility(self)
    __swig_destroy__ = _QuantLib.delete_BlackCdsOptionEngine

# Register BlackCdsOptionEngine in _QuantLib:
_QuantLib.BlackCdsOptionEngine_swigregister(BlackCdsOptionEngine)
class DiscountCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedDiscountCurve< LogLinear > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DiscountCurve self, DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), LogLinear i=LogLinear()) -> DiscountCurve"""
        _QuantLib.DiscountCurve_swiginit(self, _QuantLib.new_DiscountCurve(*args))

    def times(self):
        r"""times(DiscountCurve self) -> DoubleVector"""
        return _QuantLib.DiscountCurve_times(self)

    def data(self):
        r"""data(DiscountCurve self) -> DoubleVector"""
        return _QuantLib.DiscountCurve_data(self)

    def dates(self):
        r"""dates(DiscountCurve self) -> DateVector"""
        return _QuantLib.DiscountCurve_dates(self)

    def discounts(self):
        r"""discounts(DiscountCurve self) -> DoubleVector"""
        return _QuantLib.DiscountCurve_discounts(self)

    def nodes(self):
        r"""nodes(DiscountCurve self) -> NodeVector"""
        return _QuantLib.DiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_DiscountCurve

# Register DiscountCurve in _QuantLib:
_QuantLib.DiscountCurve_swigregister(DiscountCurve)
class MonotonicLogCubicDiscountCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedDiscountCurve< MonotonicLogCubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(MonotonicLogCubicDiscountCurve self, DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), MonotonicLogCubic i=MonotonicLogCubic()) -> MonotonicLogCubicDiscountCurve"""
        _QuantLib.MonotonicLogCubicDiscountCurve_swiginit(self, _QuantLib.new_MonotonicLogCubicDiscountCurve(*args))

    def times(self):
        r"""times(MonotonicLogCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.MonotonicLogCubicDiscountCurve_times(self)

    def data(self):
        r"""data(MonotonicLogCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.MonotonicLogCubicDiscountCurve_data(self)

    def dates(self):
        r"""dates(MonotonicLogCubicDiscountCurve self) -> DateVector"""
        return _QuantLib.MonotonicLogCubicDiscountCurve_dates(self)

    def discounts(self):
        r"""discounts(MonotonicLogCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.MonotonicLogCubicDiscountCurve_discounts(self)

    def nodes(self):
        r"""nodes(MonotonicLogCubicDiscountCurve self) -> NodeVector"""
        return _QuantLib.MonotonicLogCubicDiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubicDiscountCurve

# Register MonotonicLogCubicDiscountCurve in _QuantLib:
_QuantLib.MonotonicLogCubicDiscountCurve_swigregister(MonotonicLogCubicDiscountCurve)
class NaturalCubicDiscountCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedDiscountCurve< SplineCubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NaturalCubicDiscountCurve self, DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), SplineCubic i=SplineCubic()) -> NaturalCubicDiscountCurve"""
        _QuantLib.NaturalCubicDiscountCurve_swiginit(self, _QuantLib.new_NaturalCubicDiscountCurve(*args))

    def times(self):
        r"""times(NaturalCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.NaturalCubicDiscountCurve_times(self)

    def data(self):
        r"""data(NaturalCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.NaturalCubicDiscountCurve_data(self)

    def dates(self):
        r"""dates(NaturalCubicDiscountCurve self) -> DateVector"""
        return _QuantLib.NaturalCubicDiscountCurve_dates(self)

    def discounts(self):
        r"""discounts(NaturalCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.NaturalCubicDiscountCurve_discounts(self)

    def nodes(self):
        r"""nodes(NaturalCubicDiscountCurve self) -> NodeVector"""
        return _QuantLib.NaturalCubicDiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_NaturalCubicDiscountCurve

# Register NaturalCubicDiscountCurve in _QuantLib:
_QuantLib.NaturalCubicDiscountCurve_swigregister(NaturalCubicDiscountCurve)
class KrugerLogDiscountCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedDiscountCurve< KrugerLog > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(KrugerLogDiscountCurve self, DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), KrugerLog i=KrugerLog()) -> KrugerLogDiscountCurve"""
        _QuantLib.KrugerLogDiscountCurve_swiginit(self, _QuantLib.new_KrugerLogDiscountCurve(*args))

    def times(self):
        r"""times(KrugerLogDiscountCurve self) -> DoubleVector"""
        return _QuantLib.KrugerLogDiscountCurve_times(self)

    def data(self):
        r"""data(KrugerLogDiscountCurve self) -> DoubleVector"""
        return _QuantLib.KrugerLogDiscountCurve_data(self)

    def dates(self):
        r"""dates(KrugerLogDiscountCurve self) -> DateVector"""
        return _QuantLib.KrugerLogDiscountCurve_dates(self)

    def discounts(self):
        r"""discounts(KrugerLogDiscountCurve self) -> DoubleVector"""
        return _QuantLib.KrugerLogDiscountCurve_discounts(self)

    def nodes(self):
        r"""nodes(KrugerLogDiscountCurve self) -> NodeVector"""
        return _QuantLib.KrugerLogDiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_KrugerLogDiscountCurve

# Register KrugerLogDiscountCurve in _QuantLib:
_QuantLib.KrugerLogDiscountCurve_swigregister(KrugerLogDiscountCurve)
class NaturalLogCubicDiscountCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedDiscountCurve< SplineLogCubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NaturalLogCubicDiscountCurve self, DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), SplineLogCubic i=SplineLogCubic()) -> NaturalLogCubicDiscountCurve"""
        _QuantLib.NaturalLogCubicDiscountCurve_swiginit(self, _QuantLib.new_NaturalLogCubicDiscountCurve(*args))

    def times(self):
        r"""times(NaturalLogCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.NaturalLogCubicDiscountCurve_times(self)

    def data(self):
        r"""data(NaturalLogCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.NaturalLogCubicDiscountCurve_data(self)

    def dates(self):
        r"""dates(NaturalLogCubicDiscountCurve self) -> DateVector"""
        return _QuantLib.NaturalLogCubicDiscountCurve_dates(self)

    def discounts(self):
        r"""discounts(NaturalLogCubicDiscountCurve self) -> DoubleVector"""
        return _QuantLib.NaturalLogCubicDiscountCurve_discounts(self)

    def nodes(self):
        r"""nodes(NaturalLogCubicDiscountCurve self) -> NodeVector"""
        return _QuantLib.NaturalLogCubicDiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_NaturalLogCubicDiscountCurve

# Register NaturalLogCubicDiscountCurve in _QuantLib:
_QuantLib.NaturalLogCubicDiscountCurve_swigregister(NaturalLogCubicDiscountCurve)
class NormalDistribution(object):
    r"""Proxy of C++ NormalDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        r"""__init__(NormalDistribution self, Real average=0.0, Real sigma=1.0) -> NormalDistribution"""
        _QuantLib.NormalDistribution_swiginit(self, _QuantLib.new_NormalDistribution(average, sigma))

    def __call__(self, x):
        r"""__call__(NormalDistribution self, Real x) -> Real"""
        return _QuantLib.NormalDistribution___call__(self, x)

    def derivative(self, x):
        r"""derivative(NormalDistribution self, Real x) -> Real"""
        return _QuantLib.NormalDistribution_derivative(self, x)
    __swig_destroy__ = _QuantLib.delete_NormalDistribution

# Register NormalDistribution in _QuantLib:
_QuantLib.NormalDistribution_swigregister(NormalDistribution)
class CumulativeNormalDistribution(object):
    r"""Proxy of C++ CumulativeNormalDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        r"""__init__(CumulativeNormalDistribution self, Real average=0.0, Real sigma=1.0) -> CumulativeNormalDistribution"""
        _QuantLib.CumulativeNormalDistribution_swiginit(self, _QuantLib.new_CumulativeNormalDistribution(average, sigma))

    def __call__(self, x):
        r"""__call__(CumulativeNormalDistribution self, Real x) -> Real"""
        return _QuantLib.CumulativeNormalDistribution___call__(self, x)

    def derivative(self, x):
        r"""derivative(CumulativeNormalDistribution self, Real x) -> Real"""
        return _QuantLib.CumulativeNormalDistribution_derivative(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeNormalDistribution

# Register CumulativeNormalDistribution in _QuantLib:
_QuantLib.CumulativeNormalDistribution_swigregister(CumulativeNormalDistribution)
class InverseCumulativeNormal(object):
    r"""Proxy of C++ InverseCumulativeNormal class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        r"""__init__(InverseCumulativeNormal self, Real average=0.0, Real sigma=1.0) -> InverseCumulativeNormal"""
        _QuantLib.InverseCumulativeNormal_swiginit(self, _QuantLib.new_InverseCumulativeNormal(average, sigma))

    def __call__(self, x):
        r"""__call__(InverseCumulativeNormal self, Real x) -> Real"""
        return _QuantLib.InverseCumulativeNormal___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeNormal

# Register InverseCumulativeNormal in _QuantLib:
_QuantLib.InverseCumulativeNormal_swigregister(InverseCumulativeNormal)
class MoroInverseCumulativeNormal(object):
    r"""Proxy of C++ MoroInverseCumulativeNormal class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        r"""__init__(MoroInverseCumulativeNormal self, Real average=0.0, Real sigma=1.0) -> MoroInverseCumulativeNormal"""
        _QuantLib.MoroInverseCumulativeNormal_swiginit(self, _QuantLib.new_MoroInverseCumulativeNormal(average, sigma))

    def __call__(self, x):
        r"""__call__(MoroInverseCumulativeNormal self, Real x) -> Real"""
        return _QuantLib.MoroInverseCumulativeNormal___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_MoroInverseCumulativeNormal

# Register MoroInverseCumulativeNormal in _QuantLib:
_QuantLib.MoroInverseCumulativeNormal_swigregister(MoroInverseCumulativeNormal)
class BivariateCumulativeNormalDistribution(object):
    r"""Proxy of C++ BivariateCumulativeNormalDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho):
        r"""__init__(BivariateCumulativeNormalDistribution self, Real rho) -> BivariateCumulativeNormalDistribution"""
        _QuantLib.BivariateCumulativeNormalDistribution_swiginit(self, _QuantLib.new_BivariateCumulativeNormalDistribution(rho))

    def __call__(self, x, y):
        r"""__call__(BivariateCumulativeNormalDistribution self, Real x, Real y) -> Real"""
        return _QuantLib.BivariateCumulativeNormalDistribution___call__(self, x, y)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistribution

# Register BivariateCumulativeNormalDistribution in _QuantLib:
_QuantLib.BivariateCumulativeNormalDistribution_swigregister(BivariateCumulativeNormalDistribution)
class BinomialDistribution(object):
    r"""Proxy of C++ BinomialDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p, n):
        r"""__init__(BinomialDistribution self, Real p, BigNatural n) -> BinomialDistribution"""
        _QuantLib.BinomialDistribution_swiginit(self, _QuantLib.new_BinomialDistribution(p, n))

    def __call__(self, k):
        r"""__call__(BinomialDistribution self, BigNatural k) -> Real"""
        return _QuantLib.BinomialDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_BinomialDistribution

# Register BinomialDistribution in _QuantLib:
_QuantLib.BinomialDistribution_swigregister(BinomialDistribution)
class CumulativeBinomialDistribution(object):
    r"""Proxy of C++ CumulativeBinomialDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p, n):
        r"""__init__(CumulativeBinomialDistribution self, Real p, BigNatural n) -> CumulativeBinomialDistribution"""
        _QuantLib.CumulativeBinomialDistribution_swiginit(self, _QuantLib.new_CumulativeBinomialDistribution(p, n))

    def __call__(self, k):
        r"""__call__(CumulativeBinomialDistribution self, BigNatural k) -> Real"""
        return _QuantLib.CumulativeBinomialDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_CumulativeBinomialDistribution

# Register CumulativeBinomialDistribution in _QuantLib:
_QuantLib.CumulativeBinomialDistribution_swigregister(CumulativeBinomialDistribution)
class BivariateCumulativeNormalDistributionDr78(object):
    r"""Proxy of C++ BivariateCumulativeNormalDistributionDr78 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho):
        r"""__init__(BivariateCumulativeNormalDistributionDr78 self, Real rho) -> BivariateCumulativeNormalDistributionDr78"""
        _QuantLib.BivariateCumulativeNormalDistributionDr78_swiginit(self, _QuantLib.new_BivariateCumulativeNormalDistributionDr78(rho))

    def __call__(self, a, b):
        r"""__call__(BivariateCumulativeNormalDistributionDr78 self, Real a, Real b) -> Real"""
        return _QuantLib.BivariateCumulativeNormalDistributionDr78___call__(self, a, b)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistributionDr78

# Register BivariateCumulativeNormalDistributionDr78 in _QuantLib:
_QuantLib.BivariateCumulativeNormalDistributionDr78_swigregister(BivariateCumulativeNormalDistributionDr78)
class BivariateCumulativeNormalDistributionWe04DP(object):
    r"""Proxy of C++ BivariateCumulativeNormalDistributionWe04DP class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho):
        r"""__init__(BivariateCumulativeNormalDistributionWe04DP self, Real rho) -> BivariateCumulativeNormalDistributionWe04DP"""
        _QuantLib.BivariateCumulativeNormalDistributionWe04DP_swiginit(self, _QuantLib.new_BivariateCumulativeNormalDistributionWe04DP(rho))

    def __call__(self, a, b):
        r"""__call__(BivariateCumulativeNormalDistributionWe04DP self, Real a, Real b) -> Real"""
        return _QuantLib.BivariateCumulativeNormalDistributionWe04DP___call__(self, a, b)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistributionWe04DP

# Register BivariateCumulativeNormalDistributionWe04DP in _QuantLib:
_QuantLib.BivariateCumulativeNormalDistributionWe04DP_swigregister(BivariateCumulativeNormalDistributionWe04DP)
class CumulativeChiSquareDistribution(object):
    r"""Proxy of C++ CumulativeChiSquareDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, df):
        r"""__init__(CumulativeChiSquareDistribution self, Real df) -> CumulativeChiSquareDistribution"""
        _QuantLib.CumulativeChiSquareDistribution_swiginit(self, _QuantLib.new_CumulativeChiSquareDistribution(df))

    def __call__(self, x):
        r"""__call__(CumulativeChiSquareDistribution self, Real x) -> Real"""
        return _QuantLib.CumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeChiSquareDistribution

# Register CumulativeChiSquareDistribution in _QuantLib:
_QuantLib.CumulativeChiSquareDistribution_swigregister(CumulativeChiSquareDistribution)
class NonCentralCumulativeChiSquareDistribution(object):
    r"""Proxy of C++ NonCentralCumulativeChiSquareDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, df, ncp):
        r"""__init__(NonCentralCumulativeChiSquareDistribution self, Real df, Real ncp) -> NonCentralCumulativeChiSquareDistribution"""
        _QuantLib.NonCentralCumulativeChiSquareDistribution_swiginit(self, _QuantLib.new_NonCentralCumulativeChiSquareDistribution(df, ncp))

    def __call__(self, x):
        r"""__call__(NonCentralCumulativeChiSquareDistribution self, Real x) -> Real"""
        return _QuantLib.NonCentralCumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_NonCentralCumulativeChiSquareDistribution

# Register NonCentralCumulativeChiSquareDistribution in _QuantLib:
_QuantLib.NonCentralCumulativeChiSquareDistribution_swigregister(NonCentralCumulativeChiSquareDistribution)
class InverseNonCentralCumulativeChiSquareDistribution(object):
    r"""Proxy of C++ InverseNonCentralCumulativeChiSquareDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, df, ncp, maxEvaluations=10, accuracy=1e-8):
        r"""__init__(InverseNonCentralCumulativeChiSquareDistribution self, Real df, Real ncp, Size maxEvaluations=10, Real accuracy=1e-8) -> InverseNonCentralCumulativeChiSquareDistribution"""
        _QuantLib.InverseNonCentralCumulativeChiSquareDistribution_swiginit(self, _QuantLib.new_InverseNonCentralCumulativeChiSquareDistribution(df, ncp, maxEvaluations, accuracy))

    def __call__(self, x):
        r"""__call__(InverseNonCentralCumulativeChiSquareDistribution self, Real x) -> Real"""
        return _QuantLib.InverseNonCentralCumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseNonCentralCumulativeChiSquareDistribution

# Register InverseNonCentralCumulativeChiSquareDistribution in _QuantLib:
_QuantLib.InverseNonCentralCumulativeChiSquareDistribution_swigregister(InverseNonCentralCumulativeChiSquareDistribution)
class CumulativeGammaDistribution(object):
    r"""Proxy of C++ CumulativeGammaDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, a):
        r"""__init__(CumulativeGammaDistribution self, Real a) -> CumulativeGammaDistribution"""
        _QuantLib.CumulativeGammaDistribution_swiginit(self, _QuantLib.new_CumulativeGammaDistribution(a))

    def __call__(self, x):
        r"""__call__(CumulativeGammaDistribution self, Real x) -> Real"""
        return _QuantLib.CumulativeGammaDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeGammaDistribution

# Register CumulativeGammaDistribution in _QuantLib:
_QuantLib.CumulativeGammaDistribution_swigregister(CumulativeGammaDistribution)
class GammaFunction(object):
    r"""Proxy of C++ GammaFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def logValue(self, x):
        r"""logValue(GammaFunction self, Real x) -> Real"""
        return _QuantLib.GammaFunction_logValue(self, x)

    def __init__(self):
        r"""__init__(GammaFunction self) -> GammaFunction"""
        _QuantLib.GammaFunction_swiginit(self, _QuantLib.new_GammaFunction())
    __swig_destroy__ = _QuantLib.delete_GammaFunction

# Register GammaFunction in _QuantLib:
_QuantLib.GammaFunction_swigregister(GammaFunction)
class PoissonDistribution(object):
    r"""Proxy of C++ PoissonDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mu):
        r"""__init__(PoissonDistribution self, Real mu) -> PoissonDistribution"""
        _QuantLib.PoissonDistribution_swiginit(self, _QuantLib.new_PoissonDistribution(mu))

    def __call__(self, k):
        r"""__call__(PoissonDistribution self, BigNatural k) -> Real"""
        return _QuantLib.PoissonDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_PoissonDistribution

# Register PoissonDistribution in _QuantLib:
_QuantLib.PoissonDistribution_swigregister(PoissonDistribution)
class CumulativePoissonDistribution(object):
    r"""Proxy of C++ CumulativePoissonDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mu):
        r"""__init__(CumulativePoissonDistribution self, Real mu) -> CumulativePoissonDistribution"""
        _QuantLib.CumulativePoissonDistribution_swiginit(self, _QuantLib.new_CumulativePoissonDistribution(mu))

    def __call__(self, k):
        r"""__call__(CumulativePoissonDistribution self, BigNatural k) -> Real"""
        return _QuantLib.CumulativePoissonDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_CumulativePoissonDistribution

# Register CumulativePoissonDistribution in _QuantLib:
_QuantLib.CumulativePoissonDistribution_swigregister(CumulativePoissonDistribution)
class InverseCumulativePoisson(object):
    r"""Proxy of C++ InverseCumulativePoisson class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lambda_parameter):
        r"""__init__(InverseCumulativePoisson self, Real lambda_parameter) -> InverseCumulativePoisson"""
        _QuantLib.InverseCumulativePoisson_swiginit(self, _QuantLib.new_InverseCumulativePoisson(lambda_parameter))

    def __call__(self, x):
        r"""__call__(InverseCumulativePoisson self, Real x) -> Real"""
        return _QuantLib.InverseCumulativePoisson___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativePoisson

# Register InverseCumulativePoisson in _QuantLib:
_QuantLib.InverseCumulativePoisson_swigregister(InverseCumulativePoisson)
class StudentDistribution(object):
    r"""Proxy of C++ StudentDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(StudentDistribution self, Integer n) -> StudentDistribution"""
        _QuantLib.StudentDistribution_swiginit(self, _QuantLib.new_StudentDistribution(n))

    def __call__(self, x):
        r"""__call__(StudentDistribution self, Real x) -> Real"""
        return _QuantLib.StudentDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_StudentDistribution

# Register StudentDistribution in _QuantLib:
_QuantLib.StudentDistribution_swigregister(StudentDistribution)
class CumulativeStudentDistribution(object):
    r"""Proxy of C++ CumulativeStudentDistribution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(CumulativeStudentDistribution self, Integer n) -> CumulativeStudentDistribution"""
        _QuantLib.CumulativeStudentDistribution_swiginit(self, _QuantLib.new_CumulativeStudentDistribution(n))

    def __call__(self, x):
        r"""__call__(CumulativeStudentDistribution self, Real x) -> Real"""
        return _QuantLib.CumulativeStudentDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeStudentDistribution

# Register CumulativeStudentDistribution in _QuantLib:
_QuantLib.CumulativeStudentDistribution_swigregister(CumulativeStudentDistribution)
class InverseCumulativeStudent(object):
    r"""Proxy of C++ InverseCumulativeStudent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, accuracy=1e-6, maxIterations=50):
        r"""__init__(InverseCumulativeStudent self, Integer n, Real accuracy=1e-6, Size maxIterations=50) -> InverseCumulativeStudent"""
        _QuantLib.InverseCumulativeStudent_swiginit(self, _QuantLib.new_InverseCumulativeStudent(n, accuracy, maxIterations))

    def __call__(self, x):
        r"""__call__(InverseCumulativeStudent self, Real x) -> Real"""
        return _QuantLib.InverseCumulativeStudent___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeStudent

# Register InverseCumulativeStudent in _QuantLib:
_QuantLib.InverseCumulativeStudent_swigregister(InverseCumulativeStudent)
class Money(object):
    r"""Proxy of C++ Money class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Money self, Currency currency, Decimal value) -> Money
        __init__(Money self, Decimal value, Currency currency) -> Money
        """
        _QuantLib.Money_swiginit(self, _QuantLib.new_Money(*args))

    def currency(self):
        r"""currency(Money self) -> Currency"""
        return _QuantLib.Money_currency(self)

    def value(self):
        r"""value(Money self) -> Decimal"""
        return _QuantLib.Money_value(self)

    def rounded(self):
        r"""rounded(Money self) -> Money"""
        return _QuantLib.Money_rounded(self)

    def __pos__(self):
        r"""__pos__(Money self) -> Money"""
        return _QuantLib.Money___pos__(self)

    def __neg__(self):
        r"""__neg__(Money self) -> Money"""
        return _QuantLib.Money___neg__(self)

    def __add__(self, m):
        r"""__add__(Money self, Money m) -> Money"""
        return _QuantLib.Money___add__(self, m)

    def __sub__(self, m):
        r"""__sub__(Money self, Money m) -> Money"""
        return _QuantLib.Money___sub__(self, m)

    def __mul__(self, x):
        r"""__mul__(Money self, Decimal x) -> Money"""
        return _QuantLib.Money___mul__(self, x)

    def __truediv__(self, *args):
        return _QuantLib.Money___truediv__(self, *args)
    __div__ = __truediv__



    def __rmul__(self, x):
        r"""__rmul__(Money self, Decimal x) -> Money"""
        return _QuantLib.Money___rmul__(self, x)

    def __lt__(self, other):
        r"""__lt__(Money self, Money other) -> bool"""
        return _QuantLib.Money___lt__(self, other)

    def __gt__(self, other):
        r"""__gt__(Money self, Money other) -> bool"""
        return _QuantLib.Money___gt__(self, other)

    def __le__(self, other):
        r"""__le__(Money self, Money other) -> bool"""
        return _QuantLib.Money___le__(self, other)

    def __ge__(self, other):
        r"""__ge__(Money self, Money other) -> bool"""
        return _QuantLib.Money___ge__(self, other)

    def __cmp__(self, other):
        r"""__cmp__(Money self, Money other) -> int"""
        return _QuantLib.Money___cmp__(self, other)

    def __str__(self):
        r"""__str__(Money self) -> std::string"""
        return _QuantLib.Money___str__(self)
    NoConversion = _QuantLib.Money_NoConversion
    
    BaseCurrencyConversion = _QuantLib.Money_BaseCurrencyConversion
    
    AutomatedConversion = _QuantLib.Money_AutomatedConversion
    

    @staticmethod
    def setConversionType(type):
        r"""setConversionType(Money::ConversionType type)"""
        return _QuantLib.Money_setConversionType(type)

    @staticmethod
    def setBaseCurrency(c):
        r"""setBaseCurrency(Currency c)"""
        return _QuantLib.Money_setBaseCurrency(c)
    __swig_destroy__ = _QuantLib.delete_Money

# Register Money in _QuantLib:
_QuantLib.Money_swigregister(Money)
class ExchangeRate(object):
    r"""Proxy of C++ ExchangeRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Direct = _QuantLib.ExchangeRate_Direct
    
    Derived = _QuantLib.ExchangeRate_Derived
    

    def __init__(self, source, target, rate):
        r"""__init__(ExchangeRate self, Currency source, Currency target, Decimal rate) -> ExchangeRate"""
        _QuantLib.ExchangeRate_swiginit(self, _QuantLib.new_ExchangeRate(source, target, rate))

    def source(self):
        r"""source(ExchangeRate self) -> Currency"""
        return _QuantLib.ExchangeRate_source(self)

    def target(self):
        r"""target(ExchangeRate self) -> Currency"""
        return _QuantLib.ExchangeRate_target(self)

    def type(self):
        r"""type(ExchangeRate self) -> ExchangeRate::Type"""
        return _QuantLib.ExchangeRate_type(self)

    def rate(self):
        r"""rate(ExchangeRate self) -> Decimal"""
        return _QuantLib.ExchangeRate_rate(self)

    def exchange(self, amount):
        r"""exchange(ExchangeRate self, Money amount) -> Money"""
        return _QuantLib.ExchangeRate_exchange(self, amount)

    @staticmethod
    def chain(r1, r2):
        r"""chain(ExchangeRate r1, ExchangeRate r2) -> ExchangeRate"""
        return _QuantLib.ExchangeRate_chain(r1, r2)
    __swig_destroy__ = _QuantLib.delete_ExchangeRate

# Register ExchangeRate in _QuantLib:
_QuantLib.ExchangeRate_swigregister(ExchangeRate)
class ExchangeRateManager(object):
    r"""Proxy of C++ ExchangeRateManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def instance():
        r"""instance() -> ExchangeRateManager"""
        return _QuantLib.ExchangeRateManager_instance()

    def add(self, *args):
        r"""add(ExchangeRateManager self, ExchangeRate arg2, Date startDate=Date::minDate(), Date endDate=Date::maxDate())"""
        return _QuantLib.ExchangeRateManager_add(self, *args)

    def lookup(self, *args):
        r"""lookup(ExchangeRateManager self, Currency source, Currency target, Date date, ExchangeRate::Type type=Derived) -> ExchangeRate"""
        return _QuantLib.ExchangeRateManager_lookup(self, *args)

    def clear(self):
        r"""clear(ExchangeRateManager self)"""
        return _QuantLib.ExchangeRateManager_clear(self)
    __swig_destroy__ = _QuantLib.delete_ExchangeRateManager

# Register ExchangeRateManager in _QuantLib:
_QuantLib.ExchangeRateManager_swigregister(ExchangeRateManager)
class Settings(object):
    r"""Proxy of C++ Settings class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def instance():
        r"""instance() -> Settings"""
        return _QuantLib.Settings_instance()

    def getEvaluationDate(self):
        r"""getEvaluationDate(Settings self) -> Date"""
        return _QuantLib.Settings_getEvaluationDate(self)

    def setEvaluationDate(self, d):
        r"""setEvaluationDate(Settings self, Date d)"""
        return _QuantLib.Settings_setEvaluationDate(self, d)

    def includeReferenceDateEvents(self, b):
        r"""includeReferenceDateEvents(Settings self, bool b)"""
        return _QuantLib.Settings_includeReferenceDateEvents(self, b)

    def includeTodaysCashFlows(self, b):
        r"""includeTodaysCashFlows(Settings self, bool b)"""
        return _QuantLib.Settings_includeTodaysCashFlows(self, b)

    def setEnforcesTodaysHistoricFixings(self, b):
        r"""setEnforcesTodaysHistoricFixings(Settings self, bool b)"""
        return _QuantLib.Settings_setEnforcesTodaysHistoricFixings(self, b)

    def getEnforcesTodaysHistoricFixings(self):
        r"""getEnforcesTodaysHistoricFixings(Settings self) -> bool"""
        return _QuantLib.Settings_getEnforcesTodaysHistoricFixings(self)

    evaluationDate = property(getEvaluationDate,setEvaluationDate,None)
    includeReferenceDateCashFlows = property(None,includeReferenceDateEvents,None)
    includeReferenceDateEvents = property(None,includeReferenceDateEvents,None)
    includeTodaysCashFlows = property(None,includeTodaysCashFlows,None)
    enforcesTodaysHistoricFixings = property(getEnforcesTodaysHistoricFixings, setEnforcesTodaysHistoricFixings, None)

    __swig_destroy__ = _QuantLib.delete_Settings

# Register Settings in _QuantLib:
_QuantLib.Settings_swigregister(Settings)
class Fdm1dMesher(object):
    r"""Proxy of C++ Fdm1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size):
        r"""__init__(Fdm1dMesher self, Size size) -> Fdm1dMesher"""
        _QuantLib.Fdm1dMesher_swiginit(self, _QuantLib.new_Fdm1dMesher(size))

    def size(self):
        r"""size(Fdm1dMesher self) -> Size"""
        return _QuantLib.Fdm1dMesher_size(self)

    def dplus(self, index):
        r"""dplus(Fdm1dMesher self, Size index) -> Real"""
        return _QuantLib.Fdm1dMesher_dplus(self, index)

    def dminus(self, index):
        r"""dminus(Fdm1dMesher self, Size index) -> Real"""
        return _QuantLib.Fdm1dMesher_dminus(self, index)

    def location(self, index):
        r"""location(Fdm1dMesher self, Size index) -> Real"""
        return _QuantLib.Fdm1dMesher_location(self, index)

    def locations(self):
        r"""locations(Fdm1dMesher self) -> DoubleVector"""
        return _QuantLib.Fdm1dMesher_locations(self)
    __swig_destroy__ = _QuantLib.delete_Fdm1dMesher

# Register Fdm1dMesher in _QuantLib:
_QuantLib.Fdm1dMesher_swigregister(Fdm1dMesher)
class Fdm1dMesherVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< Fdm1dMesher > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(Fdm1dMesherVector self) -> SwigPyIterator"""
        return _QuantLib.Fdm1dMesherVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Fdm1dMesherVector self) -> bool"""
        return _QuantLib.Fdm1dMesherVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Fdm1dMesherVector self) -> bool"""
        return _QuantLib.Fdm1dMesherVector___bool__(self)

    def __len__(self):
        r"""__len__(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type"""
        return _QuantLib.Fdm1dMesherVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j) -> Fdm1dMesherVector"""
        return _QuantLib.Fdm1dMesherVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j)
        __setslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j, Fdm1dMesherVector v)
        """
        return _QuantLib.Fdm1dMesherVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j)"""
        return _QuantLib.Fdm1dMesherVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i)
        __delitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.Fdm1dMesherVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice) -> Fdm1dMesherVector
        __getitem__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &
        """
        return _QuantLib.Fdm1dMesherVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice, Fdm1dMesherVector v)
        __setitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)
        """
        return _QuantLib.Fdm1dMesherVector___setitem__(self, *args)

    def pop(self):
        r"""pop(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type"""
        return _QuantLib.Fdm1dMesherVector_pop(self)

    def append(self, x):
        r"""append(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)"""
        return _QuantLib.Fdm1dMesherVector_append(self, x)

    def empty(self):
        r"""empty(Fdm1dMesherVector self) -> bool"""
        return _QuantLib.Fdm1dMesherVector_empty(self)

    def size(self):
        r"""size(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type"""
        return _QuantLib.Fdm1dMesherVector_size(self)

    def swap(self, v):
        r"""swap(Fdm1dMesherVector self, Fdm1dMesherVector v)"""
        return _QuantLib.Fdm1dMesherVector_swap(self, v)

    def begin(self):
        r"""begin(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator"""
        return _QuantLib.Fdm1dMesherVector_begin(self)

    def end(self):
        r"""end(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator"""
        return _QuantLib.Fdm1dMesherVector_end(self)

    def rbegin(self):
        r"""rbegin(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator"""
        return _QuantLib.Fdm1dMesherVector_rbegin(self)

    def rend(self):
        r"""rend(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator"""
        return _QuantLib.Fdm1dMesherVector_rend(self)

    def clear(self):
        r"""clear(Fdm1dMesherVector self)"""
        return _QuantLib.Fdm1dMesherVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::allocator_type"""
        return _QuantLib.Fdm1dMesherVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Fdm1dMesherVector self)"""
        return _QuantLib.Fdm1dMesherVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator
        erase(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator first, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator last) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator
        """
        return _QuantLib.Fdm1dMesherVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Fdm1dMesherVector self) -> Fdm1dMesherVector
        __init__(Fdm1dMesherVector self, Fdm1dMesherVector other) -> Fdm1dMesherVector
        __init__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type size) -> Fdm1dMesherVector
        __init__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type size, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & value) -> Fdm1dMesherVector
        """
        _QuantLib.Fdm1dMesherVector_swiginit(self, _QuantLib.new_Fdm1dMesherVector(*args))

    def push_back(self, x):
        r"""push_back(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)"""
        return _QuantLib.Fdm1dMesherVector_push_back(self, x)

    def front(self):
        r"""front(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &"""
        return _QuantLib.Fdm1dMesherVector_front(self)

    def back(self):
        r"""back(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &"""
        return _QuantLib.Fdm1dMesherVector_back(self)

    def assign(self, n, x):
        r"""assign(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)"""
        return _QuantLib.Fdm1dMesherVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type new_size)
        resize(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type new_size, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)
        """
        return _QuantLib.Fdm1dMesherVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator
        insert(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)
        """
        return _QuantLib.Fdm1dMesherVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n)"""
        return _QuantLib.Fdm1dMesherVector_reserve(self, n)

    def capacity(self):
        r"""capacity(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type"""
        return _QuantLib.Fdm1dMesherVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Fdm1dMesherVector

# Register Fdm1dMesherVector in _QuantLib:
_QuantLib.Fdm1dMesherVector_swigregister(Fdm1dMesherVector)
class FdmBlackScholesMesher(Fdm1dMesher):
    r"""Proxy of C++ FdmBlackScholesMesher class."""

    thisown = 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):
        r"""__init__(FdmBlackScholesMesher self, Size size, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Time maturity, Real strike, doubleOrNull xMinConstraint=Null< Real >(), doubleOrNull xMaxConstraint=Null< Real >(), Real eps=0.0001, Real scaleFactor=1.5, DoublePair cPoint=(std::pair< Real,Real >(Null<Real>(), Null<Real>())), DividendSchedule dividendSchedule=std::vector< ext::shared_ptr< Dividend > >(), ext::shared_ptr< FdmQuantoHelper > const & fdmQuantoHelper=ext::shared_ptr< FdmQuantoHelper >(), Real spotAdjustment=0.0) -> FdmBlackScholesMesher"""
        _QuantLib.FdmBlackScholesMesher_swiginit(self, _QuantLib.new_FdmBlackScholesMesher(*args, **kwargs))

    @staticmethod
    def processHelper(s0, rTS, qTS, vol):
        r"""processHelper(QuoteHandle s0, YieldTermStructureHandle rTS, YieldTermStructureHandle qTS, Volatility vol) -> ext::shared_ptr< GeneralizedBlackScholesProcess >"""
        return _QuantLib.FdmBlackScholesMesher_processHelper(s0, rTS, qTS, vol)
    __swig_destroy__ = _QuantLib.delete_FdmBlackScholesMesher

# Register FdmBlackScholesMesher in _QuantLib:
_QuantLib.FdmBlackScholesMesher_swigregister(FdmBlackScholesMesher)
class Concentrating1dMesherPoint(object):
    r"""Proxy of C++ ext::tuple< Real,Real,bool > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg3, arg4):
        r"""__init__(Concentrating1dMesherPoint self, double arg2, double arg3, bool arg4) -> Concentrating1dMesherPoint"""
        _QuantLib.Concentrating1dMesherPoint_swiginit(self, _QuantLib.new_Concentrating1dMesherPoint(arg2, arg3, arg4))

    def first(self):
        r"""first(Concentrating1dMesherPoint self) -> double"""
        return _QuantLib.Concentrating1dMesherPoint_first(self)

    def second(self):
        r"""second(Concentrating1dMesherPoint self) -> double"""
        return _QuantLib.Concentrating1dMesherPoint_second(self)

    def third(self):
        r"""third(Concentrating1dMesherPoint self) -> bool"""
        return _QuantLib.Concentrating1dMesherPoint_third(self)
    __swig_destroy__ = _QuantLib.delete_Concentrating1dMesherPoint

# Register Concentrating1dMesherPoint in _QuantLib:
_QuantLib.Concentrating1dMesherPoint_swigregister(Concentrating1dMesherPoint)
class Concentrating1dMesherPointVector(object):
    r"""Proxy of C++ std::vector< ext::tuple< Real,Real,bool > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(Concentrating1dMesherPointVector self) -> SwigPyIterator"""
        return _QuantLib.Concentrating1dMesherPointVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Concentrating1dMesherPointVector self) -> bool"""
        return _QuantLib.Concentrating1dMesherPointVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Concentrating1dMesherPointVector self) -> bool"""
        return _QuantLib.Concentrating1dMesherPointVector___bool__(self)

    def __len__(self):
        r"""__len__(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::size_type"""
        return _QuantLib.Concentrating1dMesherPointVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j) -> Concentrating1dMesherPointVector"""
        return _QuantLib.Concentrating1dMesherPointVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j)
        __setslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j, Concentrating1dMesherPointVector v)
        """
        return _QuantLib.Concentrating1dMesherPointVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j)"""
        return _QuantLib.Concentrating1dMesherPointVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i)
        __delitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.Concentrating1dMesherPointVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice) -> Concentrating1dMesherPointVector
        __getitem__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i) -> Concentrating1dMesherPoint
        """
        return _QuantLib.Concentrating1dMesherPointVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice, Concentrating1dMesherPointVector v)
        __setitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, Concentrating1dMesherPoint x)
        """
        return _QuantLib.Concentrating1dMesherPointVector___setitem__(self, *args)

    def pop(self):
        r"""pop(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPoint"""
        return _QuantLib.Concentrating1dMesherPointVector_pop(self)

    def append(self, x):
        r"""append(Concentrating1dMesherPointVector self, Concentrating1dMesherPoint x)"""
        return _QuantLib.Concentrating1dMesherPointVector_append(self, x)

    def empty(self):
        r"""empty(Concentrating1dMesherPointVector self) -> bool"""
        return _QuantLib.Concentrating1dMesherPointVector_empty(self)

    def size(self):
        r"""size(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::size_type"""
        return _QuantLib.Concentrating1dMesherPointVector_size(self)

    def swap(self, v):
        r"""swap(Concentrating1dMesherPointVector self, Concentrating1dMesherPointVector v)"""
        return _QuantLib.Concentrating1dMesherPointVector_swap(self, v)

    def begin(self):
        r"""begin(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::iterator"""
        return _QuantLib.Concentrating1dMesherPointVector_begin(self)

    def end(self):
        r"""end(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::iterator"""
        return _QuantLib.Concentrating1dMesherPointVector_end(self)

    def rbegin(self):
        r"""rbegin(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::reverse_iterator"""
        return _QuantLib.Concentrating1dMesherPointVector_rbegin(self)

    def rend(self):
        r"""rend(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::reverse_iterator"""
        return _QuantLib.Concentrating1dMesherPointVector_rend(self)

    def clear(self):
        r"""clear(Concentrating1dMesherPointVector self)"""
        return _QuantLib.Concentrating1dMesherPointVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::allocator_type"""
        return _QuantLib.Concentrating1dMesherPointVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Concentrating1dMesherPointVector self)"""
        return _QuantLib.Concentrating1dMesherPointVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator pos) -> std::vector< ext::tuple< double,double,bool > >::iterator
        erase(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator first, std::vector< ext::tuple< double,double,bool > >::iterator last) -> std::vector< ext::tuple< double,double,bool > >::iterator
        """
        return _QuantLib.Concentrating1dMesherPointVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPointVector
        __init__(Concentrating1dMesherPointVector self, Concentrating1dMesherPointVector other) -> Concentrating1dMesherPointVector
        __init__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type size) -> Concentrating1dMesherPointVector
        __init__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type size, Concentrating1dMesherPoint value) -> Concentrating1dMesherPointVector
        """
        _QuantLib.Concentrating1dMesherPointVector_swiginit(self, _QuantLib.new_Concentrating1dMesherPointVector(*args))

    def push_back(self, x):
        r"""push_back(Concentrating1dMesherPointVector self, Concentrating1dMesherPoint x)"""
        return _QuantLib.Concentrating1dMesherPointVector_push_back(self, x)

    def front(self):
        r"""front(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPoint"""
        return _QuantLib.Concentrating1dMesherPointVector_front(self)

    def back(self):
        r"""back(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPoint"""
        return _QuantLib.Concentrating1dMesherPointVector_back(self)

    def assign(self, n, x):
        r"""assign(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type n, Concentrating1dMesherPoint x)"""
        return _QuantLib.Concentrating1dMesherPointVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type new_size)
        resize(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type new_size, Concentrating1dMesherPoint x)
        """
        return _QuantLib.Concentrating1dMesherPointVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator pos, Concentrating1dMesherPoint x) -> std::vector< ext::tuple< double,double,bool > >::iterator
        insert(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator pos, std::vector< ext::tuple< double,double,bool > >::size_type n, Concentrating1dMesherPoint x)
        """
        return _QuantLib.Concentrating1dMesherPointVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type n)"""
        return _QuantLib.Concentrating1dMesherPointVector_reserve(self, n)

    def capacity(self):
        r"""capacity(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::size_type"""
        return _QuantLib.Concentrating1dMesherPointVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Concentrating1dMesherPointVector

# Register Concentrating1dMesherPointVector in _QuantLib:
_QuantLib.Concentrating1dMesherPointVector_swigregister(Concentrating1dMesherPointVector)
class Concentrating1dMesher(Fdm1dMesher):
    r"""Proxy of C++ Concentrating1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Concentrating1dMesher self, Real start, Real end, Size size, DoublePair cPoints=(std::pair< Real,Real >(Null<Real>(), Null<Real>())), bool const requireCPoint=False) -> Concentrating1dMesher
        __init__(Concentrating1dMesher self, Real start, Real end, Size size, Concentrating1dMesherPointVector cPoints, Real tol=1e-8) -> Concentrating1dMesher
        """
        _QuantLib.Concentrating1dMesher_swiginit(self, _QuantLib.new_Concentrating1dMesher(*args))
    __swig_destroy__ = _QuantLib.delete_Concentrating1dMesher

# Register Concentrating1dMesher in _QuantLib:
_QuantLib.Concentrating1dMesher_swigregister(Concentrating1dMesher)
class ExponentialJump1dMesher(Fdm1dMesher):
    r"""Proxy of C++ ExponentialJump1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, steps, beta, jumpIntensity, eta, eps=1e-3):
        r"""__init__(ExponentialJump1dMesher self, Size steps, Real beta, Real jumpIntensity, Real eta, Real eps=1e-3) -> ExponentialJump1dMesher"""
        _QuantLib.ExponentialJump1dMesher_swiginit(self, _QuantLib.new_ExponentialJump1dMesher(steps, beta, jumpIntensity, eta, eps))
    __swig_destroy__ = _QuantLib.delete_ExponentialJump1dMesher

# Register ExponentialJump1dMesher in _QuantLib:
_QuantLib.ExponentialJump1dMesher_swigregister(ExponentialJump1dMesher)
class FdmCEV1dMesher(Fdm1dMesher):
    r"""Proxy of C++ FdmCEV1dMesher class."""

    thisown = 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):
        r"""__init__(FdmCEV1dMesher self, Size size, Real f0, Real alpha, Real beta, Time maturity, Real eps=0.0001, Real scaleFactor=1.5, DoublePair cPoint=(std::pair< Real,Real >(Null<Real>(), Null<Real>()))) -> FdmCEV1dMesher"""
        _QuantLib.FdmCEV1dMesher_swiginit(self, _QuantLib.new_FdmCEV1dMesher(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_FdmCEV1dMesher

# Register FdmCEV1dMesher in _QuantLib:
_QuantLib.FdmCEV1dMesher_swigregister(FdmCEV1dMesher)
class FdmHestonVarianceMesher(Fdm1dMesher):
    r"""Proxy of C++ FdmHestonVarianceMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size, process, maturity, tAvgSteps=10, epsilon=0.0001):
        r"""__init__(FdmHestonVarianceMesher self, Size size, ext::shared_ptr< HestonProcess > const & process, Time maturity, Size tAvgSteps=10, Real epsilon=0.0001) -> FdmHestonVarianceMesher"""
        _QuantLib.FdmHestonVarianceMesher_swiginit(self, _QuantLib.new_FdmHestonVarianceMesher(size, process, maturity, tAvgSteps, epsilon))

    def volaEstimate(self):
        r"""volaEstimate(FdmHestonVarianceMesher self) -> Real"""
        return _QuantLib.FdmHestonVarianceMesher_volaEstimate(self)
    __swig_destroy__ = _QuantLib.delete_FdmHestonVarianceMesher

# Register FdmHestonVarianceMesher in _QuantLib:
_QuantLib.FdmHestonVarianceMesher_swigregister(FdmHestonVarianceMesher)
class FdmHestonLocalVolatilityVarianceMesher(Fdm1dMesher):
    r"""Proxy of C++ FdmHestonLocalVolatilityVarianceMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size, process, leverageFct, maturity, tAvgSteps=10, epsilon=0.0001):
        r"""__init__(FdmHestonLocalVolatilityVarianceMesher self, Size size, ext::shared_ptr< HestonProcess > const & process, ext::shared_ptr< LocalVolTermStructure > const & leverageFct, Time maturity, Size tAvgSteps=10, Real epsilon=0.0001) -> FdmHestonLocalVolatilityVarianceMesher"""
        _QuantLib.FdmHestonLocalVolatilityVarianceMesher_swiginit(self, _QuantLib.new_FdmHestonLocalVolatilityVarianceMesher(size, process, leverageFct, maturity, tAvgSteps, epsilon))

    def volaEstimate(self):
        r"""volaEstimate(FdmHestonLocalVolatilityVarianceMesher self) -> Real"""
        return _QuantLib.FdmHestonLocalVolatilityVarianceMesher_volaEstimate(self)
    __swig_destroy__ = _QuantLib.delete_FdmHestonLocalVolatilityVarianceMesher

# Register FdmHestonLocalVolatilityVarianceMesher in _QuantLib:
_QuantLib.FdmHestonLocalVolatilityVarianceMesher_swigregister(FdmHestonLocalVolatilityVarianceMesher)
class FdmSimpleProcess1dMesher(Fdm1dMesher):
    r"""Proxy of C++ FdmSimpleProcess1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmSimpleProcess1dMesher self, Size size, ext::shared_ptr< StochasticProcess1D > const & process, Time maturity, Size tAvgSteps=10, Real epsilon=0.0001, doubleOrNull mandatoryPoint=Null< Real >()) -> FdmSimpleProcess1dMesher"""
        _QuantLib.FdmSimpleProcess1dMesher_swiginit(self, _QuantLib.new_FdmSimpleProcess1dMesher(*args))
    __swig_destroy__ = _QuantLib.delete_FdmSimpleProcess1dMesher

# Register FdmSimpleProcess1dMesher in _QuantLib:
_QuantLib.FdmSimpleProcess1dMesher_swigregister(FdmSimpleProcess1dMesher)
class Uniform1dMesher(Fdm1dMesher):
    r"""Proxy of C++ Uniform1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, start, end, size):
        r"""__init__(Uniform1dMesher self, Real start, Real end, Size size) -> Uniform1dMesher"""
        _QuantLib.Uniform1dMesher_swiginit(self, _QuantLib.new_Uniform1dMesher(start, end, size))
    __swig_destroy__ = _QuantLib.delete_Uniform1dMesher

# Register Uniform1dMesher in _QuantLib:
_QuantLib.Uniform1dMesher_swigregister(Uniform1dMesher)
class Predefined1dMesher(Fdm1dMesher):
    r"""Proxy of C++ Predefined1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x):
        r"""__init__(Predefined1dMesher self, DoubleVector x) -> Predefined1dMesher"""
        _QuantLib.Predefined1dMesher_swiginit(self, _QuantLib.new_Predefined1dMesher(x))
    __swig_destroy__ = _QuantLib.delete_Predefined1dMesher

# Register Predefined1dMesher in _QuantLib:
_QuantLib.Predefined1dMesher_swigregister(Predefined1dMesher)
class Glued1dMesher(Fdm1dMesher):
    r"""Proxy of C++ Glued1dMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leftMesher, rightMesher):
        r"""__init__(Glued1dMesher self, Fdm1dMesher leftMesher, Fdm1dMesher rightMesher) -> Glued1dMesher"""
        _QuantLib.Glued1dMesher_swiginit(self, _QuantLib.new_Glued1dMesher(leftMesher, rightMesher))
    __swig_destroy__ = _QuantLib.delete_Glued1dMesher

# Register Glued1dMesher in _QuantLib:
_QuantLib.Glued1dMesher_swigregister(Glued1dMesher)
class FdmLinearOpIterator(object):
    r"""Proxy of C++ FdmLinearOpIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FdmLinearOpIterator self, UnsignedIntVector dim) -> FdmLinearOpIterator
        __init__(FdmLinearOpIterator self, UnsignedIntVector dim, UnsignedIntVector coordinates, Size index) -> FdmLinearOpIterator
        """
        _QuantLib.FdmLinearOpIterator_swiginit(self, _QuantLib.new_FdmLinearOpIterator(*args))

    def coordinates(self):
        r"""coordinates(FdmLinearOpIterator self) -> UnsignedIntVector"""
        return _QuantLib.FdmLinearOpIterator_coordinates(self)

    def increment(self):
        r"""increment(FdmLinearOpIterator self)"""
        return _QuantLib.FdmLinearOpIterator_increment(self)

    def notEqual(self, iterator):
        r"""notEqual(FdmLinearOpIterator self, FdmLinearOpIterator iterator) -> bool"""
        return _QuantLib.FdmLinearOpIterator_notEqual(self, iterator)

    def index(self):
        r"""index(FdmLinearOpIterator self) -> Size"""
        return _QuantLib.FdmLinearOpIterator_index(self)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpIterator

# Register FdmLinearOpIterator in _QuantLib:
_QuantLib.FdmLinearOpIterator_swigregister(FdmLinearOpIterator)
class FdmLinearOpLayout(object):
    r"""Proxy of C++ FdmLinearOpLayout class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dim):
        r"""__init__(FdmLinearOpLayout self, UnsignedIntVector dim) -> FdmLinearOpLayout"""
        _QuantLib.FdmLinearOpLayout_swiginit(self, _QuantLib.new_FdmLinearOpLayout(dim))

    def spacing(self):
        r"""spacing(FdmLinearOpLayout self) -> UnsignedIntVector"""
        return _QuantLib.FdmLinearOpLayout_spacing(self)

    def dim(self):
        r"""dim(FdmLinearOpLayout self) -> UnsignedIntVector"""
        return _QuantLib.FdmLinearOpLayout_dim(self)

    def index(self, coordinates):
        r"""index(FdmLinearOpLayout self, UnsignedIntVector coordinates) -> Size"""
        return _QuantLib.FdmLinearOpLayout_index(self, coordinates)

    def begin(self):
        r"""begin(FdmLinearOpLayout self) -> FdmLinearOpIterator"""
        return _QuantLib.FdmLinearOpLayout_begin(self)

    def end(self):
        r"""end(FdmLinearOpLayout self) -> FdmLinearOpIterator"""
        return _QuantLib.FdmLinearOpLayout_end(self)

    def size(self):
        r"""size(FdmLinearOpLayout self) -> Size"""
        return _QuantLib.FdmLinearOpLayout_size(self)

    def neighbourhood(self, *args):
        r"""
        neighbourhood(FdmLinearOpLayout self, FdmLinearOpIterator iterator, Size i, Integer offset) -> Size
        neighbourhood(FdmLinearOpLayout self, FdmLinearOpIterator iterator, Size i1, Integer offset1, Size i2, Integer offset2) -> Size
        """
        return _QuantLib.FdmLinearOpLayout_neighbourhood(self, *args)

    def iter_neighbourhood(self, iterator, i, offset):
        r"""iter_neighbourhood(FdmLinearOpLayout self, FdmLinearOpIterator iterator, Size i, Integer offset) -> FdmLinearOpIterator"""
        return _QuantLib.FdmLinearOpLayout_iter_neighbourhood(self, iterator, i, offset)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpLayout

# Register FdmLinearOpLayout in _QuantLib:
_QuantLib.FdmLinearOpLayout_swigregister(FdmLinearOpLayout)
class FdmMesher(object):
    r"""Proxy of C++ FdmMesher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def dplus(self, iter, direction):
        r"""dplus(FdmMesher self, FdmLinearOpIterator iter, Size direction) -> Real"""
        return _QuantLib.FdmMesher_dplus(self, iter, direction)

    def dminus(self, iter, direction):
        r"""dminus(FdmMesher self, FdmLinearOpIterator iter, Size direction) -> Real"""
        return _QuantLib.FdmMesher_dminus(self, iter, direction)

    def location(self, iter, direction):
        r"""location(FdmMesher self, FdmLinearOpIterator iter, Size direction) -> Real"""
        return _QuantLib.FdmMesher_location(self, iter, direction)

    def locations(self, direction):
        r"""locations(FdmMesher self, Size direction) -> Array"""
        return _QuantLib.FdmMesher_locations(self, direction)

    def layout(self):
        r"""layout(FdmMesher self) -> ext::shared_ptr< FdmLinearOpLayout >"""
        return _QuantLib.FdmMesher_layout(self)
    __swig_destroy__ = _QuantLib.delete_FdmMesher

# Register FdmMesher in _QuantLib:
_QuantLib.FdmMesher_swigregister(FdmMesher)
class FdmMesherComposite(FdmMesher):
    r"""Proxy of C++ FdmMesherComposite class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FdmMesherComposite self, ext::shared_ptr< FdmLinearOpLayout > const & layout, Fdm1dMesherVector mesher) -> FdmMesherComposite
        __init__(FdmMesherComposite self, Fdm1dMesherVector mesher) -> FdmMesherComposite
        __init__(FdmMesherComposite self, ext::shared_ptr< Fdm1dMesher > const & mesher) -> FdmMesherComposite
        __init__(FdmMesherComposite self, ext::shared_ptr< Fdm1dMesher > const & m1, ext::shared_ptr< Fdm1dMesher > const & m2) -> FdmMesherComposite
        __init__(FdmMesherComposite self, ext::shared_ptr< Fdm1dMesher > const & m1, ext::shared_ptr< Fdm1dMesher > const & m2, ext::shared_ptr< Fdm1dMesher > const & m3) -> FdmMesherComposite
        __init__(FdmMesherComposite self, ext::shared_ptr< Fdm1dMesher > const & m1, ext::shared_ptr< Fdm1dMesher > const & m2, ext::shared_ptr< Fdm1dMesher > const & m3, ext::shared_ptr< Fdm1dMesher > const & m4) -> FdmMesherComposite
        """
        _QuantLib.FdmMesherComposite_swiginit(self, _QuantLib.new_FdmMesherComposite(*args))

    def getFdm1dMeshers(self):
        r"""getFdm1dMeshers(FdmMesherComposite self) -> Fdm1dMesherVector"""
        return _QuantLib.FdmMesherComposite_getFdm1dMeshers(self)
    __swig_destroy__ = _QuantLib.delete_FdmMesherComposite

# Register FdmMesherComposite in _QuantLib:
_QuantLib.FdmMesherComposite_swigregister(FdmMesherComposite)
class FdmLinearOp(object):
    r"""Proxy of C++ FdmLinearOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def apply(self, r):
        r"""apply(FdmLinearOp self, Array r) -> Array"""
        return _QuantLib.FdmLinearOp_apply(self, r)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOp

# Register FdmLinearOp in _QuantLib:
_QuantLib.FdmLinearOp_swigregister(FdmLinearOp)
class SparseMatrix(object):
    r"""Proxy of C++ SparseMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    row_idx = property(_QuantLib.SparseMatrix_row_idx_get, _QuantLib.SparseMatrix_row_idx_set, doc=r"""row_idx : std::vector<(unsigned int,std::allocator<(unsigned int)>)>""")
    col_idx = property(_QuantLib.SparseMatrix_col_idx_get, _QuantLib.SparseMatrix_col_idx_set, doc=r"""col_idx : std::vector<(unsigned int,std::allocator<(unsigned int)>)>""")
    data = property(_QuantLib.SparseMatrix_data_get, _QuantLib.SparseMatrix_data_set, doc=r"""data : std::vector<(Real,std::allocator<(Real)>)>""")

    def __init__(self):
        r"""__init__(SparseMatrix self) -> SparseMatrix"""
        _QuantLib.SparseMatrix_swiginit(self, _QuantLib.new_SparseMatrix())
    __swig_destroy__ = _QuantLib.delete_SparseMatrix

# Register SparseMatrix in _QuantLib:
_QuantLib.SparseMatrix_swigregister(SparseMatrix)
class FdmLinearOpComposite(FdmLinearOp):
    r"""Proxy of C++ FdmLinearOpComposite class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def size(self):
        r"""size(FdmLinearOpComposite self) -> Size"""
        return _QuantLib.FdmLinearOpComposite_size(self)

    def setTime(self, t1, t2):
        r"""setTime(FdmLinearOpComposite self, Time t1, Time t2)"""
        return _QuantLib.FdmLinearOpComposite_setTime(self, t1, t2)

    def apply_mixed(self, r):
        r"""apply_mixed(FdmLinearOpComposite self, Array r) -> Array"""
        return _QuantLib.FdmLinearOpComposite_apply_mixed(self, r)

    def apply_direction(self, direction, r):
        r"""apply_direction(FdmLinearOpComposite self, Size direction, Array r) -> Array"""
        return _QuantLib.FdmLinearOpComposite_apply_direction(self, direction, r)

    def solve_splitting(self, direction, r, s):
        r"""solve_splitting(FdmLinearOpComposite self, Size direction, Array r, Real s) -> Array"""
        return _QuantLib.FdmLinearOpComposite_solve_splitting(self, direction, r, s)

    def preconditioner(self, r, s):
        r"""preconditioner(FdmLinearOpComposite self, Array r, Real s) -> Array"""
        return _QuantLib.FdmLinearOpComposite_preconditioner(self, r, s)

    def to_sparse_matrix(self):
        r"""to_sparse_matrix(FdmLinearOpComposite self) -> ext::shared_ptr< SparseMatrix >"""
        return _QuantLib.FdmLinearOpComposite_to_sparse_matrix(self)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpComposite

# Register FdmLinearOpComposite in _QuantLib:
_QuantLib.FdmLinearOpComposite_swigregister(FdmLinearOpComposite)
class FdmLinearOpCompositeProxy(FdmLinearOpComposite):
    r"""Proxy of C++ FdmLinearOpCompositeProxy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        r"""__init__(FdmLinearOpCompositeProxy self, PyObject * callback) -> FdmLinearOpCompositeProxy"""
        _QuantLib.FdmLinearOpCompositeProxy_swiginit(self, _QuantLib.new_FdmLinearOpCompositeProxy(callback))
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpCompositeProxy

# Register FdmLinearOpCompositeProxy in _QuantLib:
_QuantLib.FdmLinearOpCompositeProxy_swigregister(FdmLinearOpCompositeProxy)
class FdmBoundaryCondition(object):
    r"""Proxy of C++ FdmBoundaryCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    NoSide = _QuantLib.FdmBoundaryCondition_NoSide
    
    Upper = _QuantLib.FdmBoundaryCondition_Upper
    
    Lower = _QuantLib.FdmBoundaryCondition_Lower
    

    def applyBeforeApplying(self, arg2):
        r"""applyBeforeApplying(FdmBoundaryCondition self, FdmLinearOp arg2)"""
        return _QuantLib.FdmBoundaryCondition_applyBeforeApplying(self, arg2)

    def applyAfterApplying(self, arg2):
        r"""applyAfterApplying(FdmBoundaryCondition self, Array arg2)"""
        return _QuantLib.FdmBoundaryCondition_applyAfterApplying(self, arg2)

    def applyBeforeSolving(self, arg2, rhs):
        r"""applyBeforeSolving(FdmBoundaryCondition self, FdmLinearOp arg2, Array rhs)"""
        return _QuantLib.FdmBoundaryCondition_applyBeforeSolving(self, arg2, rhs)

    def applyAfterSolving(self, arg2):
        r"""applyAfterSolving(FdmBoundaryCondition self, Array arg2)"""
        return _QuantLib.FdmBoundaryCondition_applyAfterSolving(self, arg2)

    def setTime(self, t):
        r"""setTime(FdmBoundaryCondition self, Time t)"""
        return _QuantLib.FdmBoundaryCondition_setTime(self, t)
    __swig_destroy__ = _QuantLib.delete_FdmBoundaryCondition

# Register FdmBoundaryCondition in _QuantLib:
_QuantLib.FdmBoundaryCondition_swigregister(FdmBoundaryCondition)
class FdmBoundaryConditionSet(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< FdmBoundaryCondition > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(FdmBoundaryConditionSet self) -> SwigPyIterator"""
        return _QuantLib.FdmBoundaryConditionSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(FdmBoundaryConditionSet self) -> bool"""
        return _QuantLib.FdmBoundaryConditionSet___nonzero__(self)

    def __bool__(self):
        r"""__bool__(FdmBoundaryConditionSet self) -> bool"""
        return _QuantLib.FdmBoundaryConditionSet___bool__(self)

    def __len__(self):
        r"""__len__(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type"""
        return _QuantLib.FdmBoundaryConditionSet___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j) -> FdmBoundaryConditionSet"""
        return _QuantLib.FdmBoundaryConditionSet___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j)
        __setslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j, FdmBoundaryConditionSet v)
        """
        return _QuantLib.FdmBoundaryConditionSet___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j)"""
        return _QuantLib.FdmBoundaryConditionSet___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i)
        __delitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.FdmBoundaryConditionSet___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice) -> FdmBoundaryConditionSet
        __getitem__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &
        """
        return _QuantLib.FdmBoundaryConditionSet___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice, FdmBoundaryConditionSet v)
        __setitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)
        """
        return _QuantLib.FdmBoundaryConditionSet___setitem__(self, *args)

    def pop(self):
        r"""pop(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type"""
        return _QuantLib.FdmBoundaryConditionSet_pop(self)

    def append(self, x):
        r"""append(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)"""
        return _QuantLib.FdmBoundaryConditionSet_append(self, x)

    def empty(self):
        r"""empty(FdmBoundaryConditionSet self) -> bool"""
        return _QuantLib.FdmBoundaryConditionSet_empty(self)

    def size(self):
        r"""size(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type"""
        return _QuantLib.FdmBoundaryConditionSet_size(self)

    def swap(self, v):
        r"""swap(FdmBoundaryConditionSet self, FdmBoundaryConditionSet v)"""
        return _QuantLib.FdmBoundaryConditionSet_swap(self, v)

    def begin(self):
        r"""begin(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator"""
        return _QuantLib.FdmBoundaryConditionSet_begin(self)

    def end(self):
        r"""end(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator"""
        return _QuantLib.FdmBoundaryConditionSet_end(self)

    def rbegin(self):
        r"""rbegin(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator"""
        return _QuantLib.FdmBoundaryConditionSet_rbegin(self)

    def rend(self):
        r"""rend(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator"""
        return _QuantLib.FdmBoundaryConditionSet_rend(self)

    def clear(self):
        r"""clear(FdmBoundaryConditionSet self)"""
        return _QuantLib.FdmBoundaryConditionSet_clear(self)

    def get_allocator(self):
        r"""get_allocator(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::allocator_type"""
        return _QuantLib.FdmBoundaryConditionSet_get_allocator(self)

    def pop_back(self):
        r"""pop_back(FdmBoundaryConditionSet self)"""
        return _QuantLib.FdmBoundaryConditionSet_pop_back(self)

    def erase(self, *args):
        r"""
        erase(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator
        erase(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator first, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator last) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator
        """
        return _QuantLib.FdmBoundaryConditionSet_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FdmBoundaryConditionSet self) -> FdmBoundaryConditionSet
        __init__(FdmBoundaryConditionSet self, FdmBoundaryConditionSet other) -> FdmBoundaryConditionSet
        __init__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type size) -> FdmBoundaryConditionSet
        __init__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type size, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & value) -> FdmBoundaryConditionSet
        """
        _QuantLib.FdmBoundaryConditionSet_swiginit(self, _QuantLib.new_FdmBoundaryConditionSet(*args))

    def push_back(self, x):
        r"""push_back(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)"""
        return _QuantLib.FdmBoundaryConditionSet_push_back(self, x)

    def front(self):
        r"""front(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &"""
        return _QuantLib.FdmBoundaryConditionSet_front(self)

    def back(self):
        r"""back(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &"""
        return _QuantLib.FdmBoundaryConditionSet_back(self)

    def assign(self, n, x):
        r"""assign(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)"""
        return _QuantLib.FdmBoundaryConditionSet_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type new_size)
        resize(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type new_size, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)
        """
        return _QuantLib.FdmBoundaryConditionSet_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator
        insert(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)
        """
        return _QuantLib.FdmBoundaryConditionSet_insert(self, *args)

    def reserve(self, n):
        r"""reserve(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n)"""
        return _QuantLib.FdmBoundaryConditionSet_reserve(self, n)

    def capacity(self):
        r"""capacity(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type"""
        return _QuantLib.FdmBoundaryConditionSet_capacity(self)
    __swig_destroy__ = _QuantLib.delete_FdmBoundaryConditionSet

# Register FdmBoundaryConditionSet in _QuantLib:
_QuantLib.FdmBoundaryConditionSet_swigregister(FdmBoundaryConditionSet)
class FdmDirichletBoundary(FdmBoundaryCondition):
    r"""Proxy of C++ FdmDirichletBoundary class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, valueOnBoundary, direction, side):
        r"""__init__(FdmDirichletBoundary self, ext::shared_ptr< FdmMesher > const & mesher, Real valueOnBoundary, Size direction, FdmDirichletBoundary::Side side) -> FdmDirichletBoundary"""
        _QuantLib.FdmDirichletBoundary_swiginit(self, _QuantLib.new_FdmDirichletBoundary(mesher, valueOnBoundary, direction, side))

    def applyAfterApplying(self, *args):
        r"""
        applyAfterApplying(FdmDirichletBoundary self, Array arg2)
        applyAfterApplying(FdmDirichletBoundary self, Real x, Real value) -> Real
        """
        return _QuantLib.FdmDirichletBoundary_applyAfterApplying(self, *args)
    __swig_destroy__ = _QuantLib.delete_FdmDirichletBoundary

# Register FdmDirichletBoundary in _QuantLib:
_QuantLib.FdmDirichletBoundary_swigregister(FdmDirichletBoundary)
class FdmDiscountDirichletBoundary(FdmBoundaryCondition):
    r"""Proxy of C++ FdmDiscountDirichletBoundary class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, rTS, maturityTime, valueOnBoundary, direction, side):
        r"""__init__(FdmDiscountDirichletBoundary self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< YieldTermStructure > const & rTS, Time maturityTime, Real valueOnBoundary, Size direction, FdmDiscountDirichletBoundary::Side side) -> FdmDiscountDirichletBoundary"""
        _QuantLib.FdmDiscountDirichletBoundary_swiginit(self, _QuantLib.new_FdmDiscountDirichletBoundary(mesher, rTS, maturityTime, valueOnBoundary, direction, side))
    __swig_destroy__ = _QuantLib.delete_FdmDiscountDirichletBoundary

# Register FdmDiscountDirichletBoundary in _QuantLib:
_QuantLib.FdmDiscountDirichletBoundary_swigregister(FdmDiscountDirichletBoundary)
class FdmTimeDepDirichletBoundary(FdmBoundaryCondition):
    r"""Proxy of C++ FdmTimeDepDirichletBoundary class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, function, direction, side):
        r"""__init__(FdmTimeDepDirichletBoundary self, ext::shared_ptr< FdmMesher > const & mesher, PyObject * function, Size direction, FdmTimeDepDirichletBoundary::Side side) -> FdmTimeDepDirichletBoundary"""
        _QuantLib.FdmTimeDepDirichletBoundary_swiginit(self, _QuantLib.new_FdmTimeDepDirichletBoundary(mesher, function, direction, side))
    __swig_destroy__ = _QuantLib.delete_FdmTimeDepDirichletBoundary

# Register FdmTimeDepDirichletBoundary in _QuantLib:
_QuantLib.FdmTimeDepDirichletBoundary_swigregister(FdmTimeDepDirichletBoundary)
class FdmBatesOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmBatesOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmBatesOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< BatesProcess > const & batesProcess, FdmBoundaryConditionSet bcSet, Size integroIntegrationOrder, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >()) -> FdmBatesOp"""
        _QuantLib.FdmBatesOp_swiginit(self, _QuantLib.new_FdmBatesOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmBatesOp

# Register FdmBatesOp in _QuantLib:
_QuantLib.FdmBatesOp_swigregister(FdmBatesOp)
class FdmBlackScholesOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmBlackScholesOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmBlackScholesOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real strike, bool localVol=False, doubleOrNull illegalLocalVolOverwrite=-Null< Real >(), Size direction=0, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >()) -> FdmBlackScholesOp"""
        _QuantLib.FdmBlackScholesOp_swiginit(self, _QuantLib.new_FdmBlackScholesOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmBlackScholesOp

# Register FdmBlackScholesOp in _QuantLib:
_QuantLib.FdmBlackScholesOp_swigregister(FdmBlackScholesOp)
class Fdm2dBlackScholesOp(FdmLinearOpComposite):
    r"""Proxy of C++ Fdm2dBlackScholesOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(Fdm2dBlackScholesOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p2, Real correlation, Time maturity, bool localVol=False, doubleOrNull illegalLocalVolOverwrite=-Null< Real >()) -> Fdm2dBlackScholesOp"""
        _QuantLib.Fdm2dBlackScholesOp_swiginit(self, _QuantLib.new_Fdm2dBlackScholesOp(*args))
    __swig_destroy__ = _QuantLib.delete_Fdm2dBlackScholesOp

# Register Fdm2dBlackScholesOp in _QuantLib:
_QuantLib.Fdm2dBlackScholesOp_swigregister(Fdm2dBlackScholesOp)
class FdmCEVOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmCEVOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, rTS, f0, alpha, beta, direction):
        r"""__init__(FdmCEVOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< YieldTermStructure > const & rTS, Real f0, Real alpha, Real beta, Size direction) -> FdmCEVOp"""
        _QuantLib.FdmCEVOp_swiginit(self, _QuantLib.new_FdmCEVOp(mesher, rTS, f0, alpha, beta, direction))
    __swig_destroy__ = _QuantLib.delete_FdmCEVOp

# Register FdmCEVOp in _QuantLib:
_QuantLib.FdmCEVOp_swigregister(FdmCEVOp)
class FdmG2Op(FdmLinearOpComposite):
    r"""Proxy of C++ FdmG2Op class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, model, direction1, direction2):
        r"""__init__(FdmG2Op self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< G2 > const & model, Size direction1, Size direction2) -> FdmG2Op"""
        _QuantLib.FdmG2Op_swiginit(self, _QuantLib.new_FdmG2Op(mesher, model, direction1, direction2))
    __swig_destroy__ = _QuantLib.delete_FdmG2Op

# Register FdmG2Op in _QuantLib:
_QuantLib.FdmG2Op_swigregister(FdmG2Op)
class FdmHestonHullWhiteOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmHestonHullWhiteOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, hestonProcess, hwProcess, equityShortRateCorrelation):
        r"""__init__(FdmHestonHullWhiteOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< HullWhiteProcess > const & hwProcess, Real equityShortRateCorrelation) -> FdmHestonHullWhiteOp"""
        _QuantLib.FdmHestonHullWhiteOp_swiginit(self, _QuantLib.new_FdmHestonHullWhiteOp(mesher, hestonProcess, hwProcess, equityShortRateCorrelation))
    __swig_destroy__ = _QuantLib.delete_FdmHestonHullWhiteOp

# Register FdmHestonHullWhiteOp in _QuantLib:
_QuantLib.FdmHestonHullWhiteOp_swigregister(FdmHestonHullWhiteOp)
class FdmHestonOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmHestonOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmHestonOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >()) -> FdmHestonOp"""
        _QuantLib.FdmHestonOp_swiginit(self, _QuantLib.new_FdmHestonOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmHestonOp

# Register FdmHestonOp in _QuantLib:
_QuantLib.FdmHestonOp_swigregister(FdmHestonOp)
class FdmHullWhiteOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmHullWhiteOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, model, direction):
        r"""__init__(FdmHullWhiteOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HullWhite > const & model, Size direction) -> FdmHullWhiteOp"""
        _QuantLib.FdmHullWhiteOp_swiginit(self, _QuantLib.new_FdmHullWhiteOp(mesher, model, direction))
    __swig_destroy__ = _QuantLib.delete_FdmHullWhiteOp

# Register FdmHullWhiteOp in _QuantLib:
_QuantLib.FdmHullWhiteOp_swigregister(FdmHullWhiteOp)
class FdmLocalVolFwdOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmLocalVolFwdOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, spot, rTS, qTS, localVol, direction=0):
        r"""__init__(FdmLocalVolFwdOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< Quote > const & spot, ext::shared_ptr< YieldTermStructure > const & rTS, ext::shared_ptr< YieldTermStructure > const & qTS, ext::shared_ptr< LocalVolTermStructure > const & localVol, Size direction=0) -> FdmLocalVolFwdOp"""
        _QuantLib.FdmLocalVolFwdOp_swiginit(self, _QuantLib.new_FdmLocalVolFwdOp(mesher, spot, rTS, qTS, localVol, direction))
    __swig_destroy__ = _QuantLib.delete_FdmLocalVolFwdOp

# Register FdmLocalVolFwdOp in _QuantLib:
_QuantLib.FdmLocalVolFwdOp_swigregister(FdmLocalVolFwdOp)
class FdmOrnsteinUhlenbeckOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmOrnsteinUhlenbeckOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, p, rTS, direction=0):
        r"""__init__(FdmOrnsteinUhlenbeckOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< OrnsteinUhlenbeckProcess > const & p, ext::shared_ptr< YieldTermStructure > const & rTS, Size direction=0) -> FdmOrnsteinUhlenbeckOp"""
        _QuantLib.FdmOrnsteinUhlenbeckOp_swiginit(self, _QuantLib.new_FdmOrnsteinUhlenbeckOp(mesher, p, rTS, direction))
    __swig_destroy__ = _QuantLib.delete_FdmOrnsteinUhlenbeckOp

# Register FdmOrnsteinUhlenbeckOp in _QuantLib:
_QuantLib.FdmOrnsteinUhlenbeckOp_swigregister(FdmOrnsteinUhlenbeckOp)
class FdmSabrOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmSabrOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, rTS, f0, alpha, beta, nu, rho):
        r"""__init__(FdmSabrOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< YieldTermStructure > const & rTS, Real f0, Real alpha, Real beta, Real nu, Real rho) -> FdmSabrOp"""
        _QuantLib.FdmSabrOp_swiginit(self, _QuantLib.new_FdmSabrOp(mesher, rTS, f0, alpha, beta, nu, rho))
    __swig_destroy__ = _QuantLib.delete_FdmSabrOp

# Register FdmSabrOp in _QuantLib:
_QuantLib.FdmSabrOp_swigregister(FdmSabrOp)
class FdmZabrOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmZabrOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, beta, nu, rho, gamma):
        r"""__init__(FdmZabrOp self, ext::shared_ptr< FdmMesher > const & mesher, Real const beta, Real const nu, Real const rho, Real const gamma) -> FdmZabrOp"""
        _QuantLib.FdmZabrOp_swiginit(self, _QuantLib.new_FdmZabrOp(mesher, beta, nu, rho, gamma))
    __swig_destroy__ = _QuantLib.delete_FdmZabrOp

# Register FdmZabrOp in _QuantLib:
_QuantLib.FdmZabrOp_swigregister(FdmZabrOp)
class FdmDupire1dOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmDupire1dOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, localVolatility):
        r"""__init__(FdmDupire1dOp self, ext::shared_ptr< FdmMesher > const & mesher, Array localVolatility) -> FdmDupire1dOp"""
        _QuantLib.FdmDupire1dOp_swiginit(self, _QuantLib.new_FdmDupire1dOp(mesher, localVolatility))
    __swig_destroy__ = _QuantLib.delete_FdmDupire1dOp

# Register FdmDupire1dOp in _QuantLib:
_QuantLib.FdmDupire1dOp_swigregister(FdmDupire1dOp)
class FdmBlackScholesFwdOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmBlackScholesFwdOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmBlackScholesFwdOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real strike, bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), Size direction=0) -> FdmBlackScholesFwdOp"""
        _QuantLib.FdmBlackScholesFwdOp_swiginit(self, _QuantLib.new_FdmBlackScholesFwdOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmBlackScholesFwdOp

# Register FdmBlackScholesFwdOp in _QuantLib:
_QuantLib.FdmBlackScholesFwdOp_swigregister(FdmBlackScholesFwdOp)
class FdmSquareRootFwdOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmSquareRootFwdOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Plain = _QuantLib.FdmSquareRootFwdOp_Plain
    
    Power = _QuantLib.FdmSquareRootFwdOp_Power
    
    Log = _QuantLib.FdmSquareRootFwdOp_Log
    

    def __init__(self, *args):
        r"""__init__(FdmSquareRootFwdOp self, ext::shared_ptr< FdmMesher > const & mesher, Real kappa, Real theta, Real sigma, Size direction, FdmSquareRootFwdOp::TransformationType type=Plain) -> FdmSquareRootFwdOp"""
        _QuantLib.FdmSquareRootFwdOp_swiginit(self, _QuantLib.new_FdmSquareRootFwdOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmSquareRootFwdOp

# Register FdmSquareRootFwdOp in _QuantLib:
_QuantLib.FdmSquareRootFwdOp_swigregister(FdmSquareRootFwdOp)
class FdmHestonFwdOp(FdmLinearOpComposite):
    r"""Proxy of C++ FdmHestonFwdOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmHestonFwdOp self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HestonProcess > const & process, FdmSquareRootFwdOp::TransformationType type=Plain, ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >()) -> FdmHestonFwdOp"""
        _QuantLib.FdmHestonFwdOp_swiginit(self, _QuantLib.new_FdmHestonFwdOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmHestonFwdOp

# Register FdmHestonFwdOp in _QuantLib:
_QuantLib.FdmHestonFwdOp_swigregister(FdmHestonFwdOp)
class TripleBandLinearOp(FdmLinearOp):
    r"""Proxy of C++ TripleBandLinearOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, mesher):
        r"""__init__(TripleBandLinearOp self, Size direction, ext::shared_ptr< FdmMesher > const & mesher) -> TripleBandLinearOp"""
        _QuantLib.TripleBandLinearOp_swiginit(self, _QuantLib.new_TripleBandLinearOp(direction, mesher))

    def apply(self, r):
        r"""apply(TripleBandLinearOp self, Array r) -> Array"""
        return _QuantLib.TripleBandLinearOp_apply(self, r)

    def solve_splitting(self, r, a, b=1.0):
        r"""solve_splitting(TripleBandLinearOp self, Array r, Real a, Real b=1.0) -> Array"""
        return _QuantLib.TripleBandLinearOp_solve_splitting(self, r, a, b)

    def mult(self, u):
        r"""mult(TripleBandLinearOp self, Array u) -> TripleBandLinearOp"""
        return _QuantLib.TripleBandLinearOp_mult(self, u)

    def multR(self, u):
        r"""multR(TripleBandLinearOp self, Array u) -> TripleBandLinearOp"""
        return _QuantLib.TripleBandLinearOp_multR(self, u)

    def add(self, *args):
        r"""
        add(TripleBandLinearOp self, TripleBandLinearOp m) -> TripleBandLinearOp
        add(TripleBandLinearOp self, Array u) -> TripleBandLinearOp
        """
        return _QuantLib.TripleBandLinearOp_add(self, *args)

    def axpyb(self, a, x, y, b):
        r"""axpyb(TripleBandLinearOp self, Array a, TripleBandLinearOp x, TripleBandLinearOp y, Array b)"""
        return _QuantLib.TripleBandLinearOp_axpyb(self, a, x, y, b)

    def swap(self, m):
        r"""swap(TripleBandLinearOp self, TripleBandLinearOp m)"""
        return _QuantLib.TripleBandLinearOp_swap(self, m)
    __swig_destroy__ = _QuantLib.delete_TripleBandLinearOp

# Register TripleBandLinearOp in _QuantLib:
_QuantLib.TripleBandLinearOp_swigregister(TripleBandLinearOp)
class FirstDerivativeOp(TripleBandLinearOp):
    r"""Proxy of C++ FirstDerivativeOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, mesher):
        r"""__init__(FirstDerivativeOp self, Size direction, ext::shared_ptr< FdmMesher > const & mesher) -> FirstDerivativeOp"""
        _QuantLib.FirstDerivativeOp_swiginit(self, _QuantLib.new_FirstDerivativeOp(direction, mesher))
    __swig_destroy__ = _QuantLib.delete_FirstDerivativeOp

# Register FirstDerivativeOp in _QuantLib:
_QuantLib.FirstDerivativeOp_swigregister(FirstDerivativeOp)
class SecondDerivativeOp(TripleBandLinearOp):
    r"""Proxy of C++ SecondDerivativeOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, mesher):
        r"""__init__(SecondDerivativeOp self, Size direction, ext::shared_ptr< FdmMesher > const & mesher) -> SecondDerivativeOp"""
        _QuantLib.SecondDerivativeOp_swiginit(self, _QuantLib.new_SecondDerivativeOp(direction, mesher))
    __swig_destroy__ = _QuantLib.delete_SecondDerivativeOp

# Register SecondDerivativeOp in _QuantLib:
_QuantLib.SecondDerivativeOp_swigregister(SecondDerivativeOp)
class NinePointLinearOp(FdmLinearOp):
    r"""Proxy of C++ NinePointLinearOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, d0, d1, mesher):
        r"""__init__(NinePointLinearOp self, Size d0, Size d1, ext::shared_ptr< FdmMesher > const & mesher) -> NinePointLinearOp"""
        _QuantLib.NinePointLinearOp_swiginit(self, _QuantLib.new_NinePointLinearOp(d0, d1, mesher))
    __swig_destroy__ = _QuantLib.delete_NinePointLinearOp

# Register NinePointLinearOp in _QuantLib:
_QuantLib.NinePointLinearOp_swigregister(NinePointLinearOp)
class SecondOrderMixedDerivativeOp(NinePointLinearOp):
    r"""Proxy of C++ SecondOrderMixedDerivativeOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, d0, d1, mesher):
        r"""__init__(SecondOrderMixedDerivativeOp self, Size d0, Size d1, ext::shared_ptr< FdmMesher > const & mesher) -> SecondOrderMixedDerivativeOp"""
        _QuantLib.SecondOrderMixedDerivativeOp_swiginit(self, _QuantLib.new_SecondOrderMixedDerivativeOp(d0, d1, mesher))
    __swig_destroy__ = _QuantLib.delete_SecondOrderMixedDerivativeOp

# Register SecondOrderMixedDerivativeOp in _QuantLib:
_QuantLib.SecondOrderMixedDerivativeOp_swigregister(SecondOrderMixedDerivativeOp)
class NthOrderDerivativeOp(FdmLinearOp):
    r"""Proxy of C++ NthOrderDerivativeOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, order, nPoints, mesher):
        r"""__init__(NthOrderDerivativeOp self, Size direction, Size order, Integer nPoints, ext::shared_ptr< FdmMesher > const & mesher) -> NthOrderDerivativeOp"""
        _QuantLib.NthOrderDerivativeOp_swiginit(self, _QuantLib.new_NthOrderDerivativeOp(direction, order, nPoints, mesher))
    __swig_destroy__ = _QuantLib.delete_NthOrderDerivativeOp

# Register NthOrderDerivativeOp in _QuantLib:
_QuantLib.NthOrderDerivativeOp_swigregister(NthOrderDerivativeOp)
class CraigSneydScheme(object):
    r"""Proxy of C++ CraigSneydScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(CraigSneydScheme self, Real theta, Real mu, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet()) -> CraigSneydScheme"""
        _QuantLib.CraigSneydScheme_swiginit(self, _QuantLib.new_CraigSneydScheme(*args))

    def step(self, a, t):
        r"""step(CraigSneydScheme self, Array a, Time t)"""
        return _QuantLib.CraigSneydScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(CraigSneydScheme self, Time dt)"""
        return _QuantLib.CraigSneydScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_CraigSneydScheme

# Register CraigSneydScheme in _QuantLib:
_QuantLib.CraigSneydScheme_swigregister(CraigSneydScheme)
class ImplicitEulerScheme(object):
    r"""Proxy of C++ ImplicitEulerScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BiCGstab = _QuantLib.ImplicitEulerScheme_BiCGstab
    
    GMRES = _QuantLib.ImplicitEulerScheme_GMRES
    

    def __init__(self, *args, **kwargs):
        r"""__init__(ImplicitEulerScheme self, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet(), Real relTol=1e-8, ImplicitEulerScheme::SolverType solverType=BiCGstab) -> ImplicitEulerScheme"""
        _QuantLib.ImplicitEulerScheme_swiginit(self, _QuantLib.new_ImplicitEulerScheme(*args, **kwargs))

    def step(self, a, t):
        r"""step(ImplicitEulerScheme self, Array a, Time t)"""
        return _QuantLib.ImplicitEulerScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(ImplicitEulerScheme self, Time dt)"""
        return _QuantLib.ImplicitEulerScheme_setStep(self, dt)

    def numberOfIterations(self):
        r"""numberOfIterations(ImplicitEulerScheme self) -> Size"""
        return _QuantLib.ImplicitEulerScheme_numberOfIterations(self)
    __swig_destroy__ = _QuantLib.delete_ImplicitEulerScheme

# Register ImplicitEulerScheme in _QuantLib:
_QuantLib.ImplicitEulerScheme_swigregister(ImplicitEulerScheme)
class CrankNicolsonScheme(object):
    r"""Proxy of C++ CrankNicolsonScheme class."""

    thisown = 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):
        r"""__init__(CrankNicolsonScheme self, Real theta, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet(), Real relTol=1e-8, ImplicitEulerScheme::SolverType solverType=BiCGstab) -> CrankNicolsonScheme"""
        _QuantLib.CrankNicolsonScheme_swiginit(self, _QuantLib.new_CrankNicolsonScheme(*args, **kwargs))

    def step(self, a, t):
        r"""step(CrankNicolsonScheme self, Array a, Time t)"""
        return _QuantLib.CrankNicolsonScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(CrankNicolsonScheme self, Time dt)"""
        return _QuantLib.CrankNicolsonScheme_setStep(self, dt)

    def numberOfIterations(self):
        r"""numberOfIterations(CrankNicolsonScheme self) -> Size"""
        return _QuantLib.CrankNicolsonScheme_numberOfIterations(self)
    __swig_destroy__ = _QuantLib.delete_CrankNicolsonScheme

# Register CrankNicolsonScheme in _QuantLib:
_QuantLib.CrankNicolsonScheme_swigregister(CrankNicolsonScheme)
class DouglasScheme(object):
    r"""Proxy of C++ DouglasScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DouglasScheme self, Real theta, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet()) -> DouglasScheme"""
        _QuantLib.DouglasScheme_swiginit(self, _QuantLib.new_DouglasScheme(*args))

    def step(self, a, t):
        r"""step(DouglasScheme self, Array a, Time t)"""
        return _QuantLib.DouglasScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(DouglasScheme self, Time dt)"""
        return _QuantLib.DouglasScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_DouglasScheme

# Register DouglasScheme in _QuantLib:
_QuantLib.DouglasScheme_swigregister(DouglasScheme)
class ExplicitEulerScheme(object):
    r"""Proxy of C++ ExplicitEulerScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ExplicitEulerScheme self, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet()) -> ExplicitEulerScheme"""
        _QuantLib.ExplicitEulerScheme_swiginit(self, _QuantLib.new_ExplicitEulerScheme(*args))

    def step(self, a, t):
        r"""step(ExplicitEulerScheme self, Array a, Time t)"""
        return _QuantLib.ExplicitEulerScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(ExplicitEulerScheme self, Time dt)"""
        return _QuantLib.ExplicitEulerScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_ExplicitEulerScheme

# Register ExplicitEulerScheme in _QuantLib:
_QuantLib.ExplicitEulerScheme_swigregister(ExplicitEulerScheme)
class HundsdorferScheme(object):
    r"""Proxy of C++ HundsdorferScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(HundsdorferScheme self, Real theta, Real mu, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet()) -> HundsdorferScheme"""
        _QuantLib.HundsdorferScheme_swiginit(self, _QuantLib.new_HundsdorferScheme(*args))

    def step(self, a, t):
        r"""step(HundsdorferScheme self, Array a, Time t)"""
        return _QuantLib.HundsdorferScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(HundsdorferScheme self, Time dt)"""
        return _QuantLib.HundsdorferScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_HundsdorferScheme

# Register HundsdorferScheme in _QuantLib:
_QuantLib.HundsdorferScheme_swigregister(HundsdorferScheme)
class MethodOfLinesScheme(object):
    r"""Proxy of C++ MethodOfLinesScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(MethodOfLinesScheme self, Real const eps, Real const relInitStepSize, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet()) -> MethodOfLinesScheme"""
        _QuantLib.MethodOfLinesScheme_swiginit(self, _QuantLib.new_MethodOfLinesScheme(*args))

    def step(self, a, t):
        r"""step(MethodOfLinesScheme self, Array a, Time t)"""
        return _QuantLib.MethodOfLinesScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(MethodOfLinesScheme self, Time dt)"""
        return _QuantLib.MethodOfLinesScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_MethodOfLinesScheme

# Register MethodOfLinesScheme in _QuantLib:
_QuantLib.MethodOfLinesScheme_swigregister(MethodOfLinesScheme)
class ModifiedCraigSneydScheme(object):
    r"""Proxy of C++ ModifiedCraigSneydScheme class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ModifiedCraigSneydScheme self, Real theta, Real mu, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet()) -> ModifiedCraigSneydScheme"""
        _QuantLib.ModifiedCraigSneydScheme_swiginit(self, _QuantLib.new_ModifiedCraigSneydScheme(*args))

    def step(self, a, t):
        r"""step(ModifiedCraigSneydScheme self, Array a, Time t)"""
        return _QuantLib.ModifiedCraigSneydScheme_step(self, a, t)

    def setStep(self, dt):
        r"""setStep(ModifiedCraigSneydScheme self, Time dt)"""
        return _QuantLib.ModifiedCraigSneydScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_ModifiedCraigSneydScheme

# Register ModifiedCraigSneydScheme in _QuantLib:
_QuantLib.ModifiedCraigSneydScheme_swigregister(ModifiedCraigSneydScheme)
class FdmStepCondition(object):
    r"""Proxy of C++ StepCondition< Array > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def applyTo(self, a, t):
        r"""applyTo(FdmStepCondition self, Array a, Time t)"""
        return _QuantLib.FdmStepCondition_applyTo(self, a, t)
    __swig_destroy__ = _QuantLib.delete_FdmStepCondition

# Register FdmStepCondition in _QuantLib:
_QuantLib.FdmStepCondition_swigregister(FdmStepCondition)
class FdmStepConditionProxy(FdmStepCondition):
    r"""Proxy of C++ FdmStepConditionProxy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        r"""__init__(FdmStepConditionProxy self, PyObject * callback) -> FdmStepConditionProxy"""
        _QuantLib.FdmStepConditionProxy_swiginit(self, _QuantLib.new_FdmStepConditionProxy(callback))
    __swig_destroy__ = _QuantLib.delete_FdmStepConditionProxy

# Register FdmStepConditionProxy in _QuantLib:
_QuantLib.FdmStepConditionProxy_swigregister(FdmStepConditionProxy)
class FdmInnerValueCalculator(object):
    r"""Proxy of C++ FdmInnerValueCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def innerValue(self, iter, t):
        r"""innerValue(FdmInnerValueCalculator self, FdmLinearOpIterator iter, Time t) -> Real"""
        return _QuantLib.FdmInnerValueCalculator_innerValue(self, iter, t)

    def avgInnerValue(self, iter, t):
        r"""avgInnerValue(FdmInnerValueCalculator self, FdmLinearOpIterator iter, Time t) -> Real"""
        return _QuantLib.FdmInnerValueCalculator_avgInnerValue(self, iter, t)
    __swig_destroy__ = _QuantLib.delete_FdmInnerValueCalculator

# Register FdmInnerValueCalculator in _QuantLib:
_QuantLib.FdmInnerValueCalculator_swigregister(FdmInnerValueCalculator)
class FdmInnerValueCalculatorProxy(FdmInnerValueCalculator):
    r"""Proxy of C++ FdmInnerValueCalculatorProxy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        r"""__init__(FdmInnerValueCalculatorProxy self, PyObject * callback) -> FdmInnerValueCalculatorProxy"""
        _QuantLib.FdmInnerValueCalculatorProxy_swiginit(self, _QuantLib.new_FdmInnerValueCalculatorProxy(callback))
    __swig_destroy__ = _QuantLib.delete_FdmInnerValueCalculatorProxy

# Register FdmInnerValueCalculatorProxy in _QuantLib:
_QuantLib.FdmInnerValueCalculatorProxy_swigregister(FdmInnerValueCalculatorProxy)
class FdmCellAveragingInnerValue(FdmInnerValueCalculator):
    r"""Proxy of C++ FdmCellAveragingInnerValue class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FdmCellAveragingInnerValue self, ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher, Size direction, PyObject * gridMapping) -> FdmCellAveragingInnerValue
        __init__(FdmCellAveragingInnerValue self, ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmCellAveragingInnerValue
        """
        _QuantLib.FdmCellAveragingInnerValue_swiginit(self, _QuantLib.new_FdmCellAveragingInnerValue(*args))
    __swig_destroy__ = _QuantLib.delete_FdmCellAveragingInnerValue

# Register FdmCellAveragingInnerValue in _QuantLib:
_QuantLib.FdmCellAveragingInnerValue_swigregister(FdmCellAveragingInnerValue)
class FdmLogInnerValue(FdmCellAveragingInnerValue):
    r"""Proxy of C++ FdmLogInnerValue class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, mesher, direction):
        r"""__init__(FdmLogInnerValue self, ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmLogInnerValue"""
        _QuantLib.FdmLogInnerValue_swiginit(self, _QuantLib.new_FdmLogInnerValue(payoff, mesher, direction))
    __swig_destroy__ = _QuantLib.delete_FdmLogInnerValue

# Register FdmLogInnerValue in _QuantLib:
_QuantLib.FdmLogInnerValue_swigregister(FdmLogInnerValue)
class FdmLogBasketInnerValue(FdmInnerValueCalculator):
    r"""Proxy of C++ FdmLogBasketInnerValue class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, mesher):
        r"""__init__(FdmLogBasketInnerValue self, ext::shared_ptr< BasketPayoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher) -> FdmLogBasketInnerValue"""
        _QuantLib.FdmLogBasketInnerValue_swiginit(self, _QuantLib.new_FdmLogBasketInnerValue(payoff, mesher))
    __swig_destroy__ = _QuantLib.delete_FdmLogBasketInnerValue

# Register FdmLogBasketInnerValue in _QuantLib:
_QuantLib.FdmLogBasketInnerValue_swigregister(FdmLogBasketInnerValue)
class FdmZeroInnerValue(FdmInnerValueCalculator):
    r"""Proxy of C++ FdmZeroInnerValue class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(FdmZeroInnerValue self) -> FdmZeroInnerValue"""
        _QuantLib.FdmZeroInnerValue_swiginit(self, _QuantLib.new_FdmZeroInnerValue())
    __swig_destroy__ = _QuantLib.delete_FdmZeroInnerValue

# Register FdmZeroInnerValue in _QuantLib:
_QuantLib.FdmZeroInnerValue_swigregister(FdmZeroInnerValue)
class TimeToDateMap(object):
    r"""Proxy of C++ std::map< Time,Date > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(TimeToDateMap self) -> SwigPyIterator"""
        return _QuantLib.TimeToDateMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(TimeToDateMap self) -> bool"""
        return _QuantLib.TimeToDateMap___nonzero__(self)

    def __bool__(self):
        r"""__bool__(TimeToDateMap self) -> bool"""
        return _QuantLib.TimeToDateMap___bool__(self)

    def __len__(self):
        r"""__len__(TimeToDateMap self) -> std::map< double,Date >::size_type"""
        return _QuantLib.TimeToDateMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""__getitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key) -> Date"""
        return _QuantLib.TimeToDateMap___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key)"""
        return _QuantLib.TimeToDateMap___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(TimeToDateMap self, std::map< double,Date >::key_type const & key) -> bool"""
        return _QuantLib.TimeToDateMap_has_key(self, key)

    def keys(self):
        r"""keys(TimeToDateMap self) -> PyObject *"""
        return _QuantLib.TimeToDateMap_keys(self)

    def values(self):
        r"""values(TimeToDateMap self) -> PyObject *"""
        return _QuantLib.TimeToDateMap_values(self)

    def items(self):
        r"""items(TimeToDateMap self) -> PyObject *"""
        return _QuantLib.TimeToDateMap_items(self)

    def __contains__(self, key):
        r"""__contains__(TimeToDateMap self, std::map< double,Date >::key_type const & key) -> bool"""
        return _QuantLib.TimeToDateMap___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(TimeToDateMap self) -> SwigPyIterator"""
        return _QuantLib.TimeToDateMap_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(TimeToDateMap self) -> SwigPyIterator"""
        return _QuantLib.TimeToDateMap_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key)
        __setitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key, Date x)
        """
        return _QuantLib.TimeToDateMap___setitem__(self, *args)

    def asdict(self):
        r"""asdict(TimeToDateMap self) -> PyObject *"""
        return _QuantLib.TimeToDateMap_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(TimeToDateMap self, std::less< double > const & other) -> TimeToDateMap
        __init__(TimeToDateMap self) -> TimeToDateMap
        __init__(TimeToDateMap self, TimeToDateMap other) -> TimeToDateMap
        """
        _QuantLib.TimeToDateMap_swiginit(self, _QuantLib.new_TimeToDateMap(*args))

    def empty(self):
        r"""empty(TimeToDateMap self) -> bool"""
        return _QuantLib.TimeToDateMap_empty(self)

    def size(self):
        r"""size(TimeToDateMap self) -> std::map< double,Date >::size_type"""
        return _QuantLib.TimeToDateMap_size(self)

    def swap(self, v):
        r"""swap(TimeToDateMap self, TimeToDateMap v)"""
        return _QuantLib.TimeToDateMap_swap(self, v)

    def begin(self):
        r"""begin(TimeToDateMap self) -> std::map< double,Date >::iterator"""
        return _QuantLib.TimeToDateMap_begin(self)

    def end(self):
        r"""end(TimeToDateMap self) -> std::map< double,Date >::iterator"""
        return _QuantLib.TimeToDateMap_end(self)

    def rbegin(self):
        r"""rbegin(TimeToDateMap self) -> std::map< double,Date >::reverse_iterator"""
        return _QuantLib.TimeToDateMap_rbegin(self)

    def rend(self):
        r"""rend(TimeToDateMap self) -> std::map< double,Date >::reverse_iterator"""
        return _QuantLib.TimeToDateMap_rend(self)

    def clear(self):
        r"""clear(TimeToDateMap self)"""
        return _QuantLib.TimeToDateMap_clear(self)

    def get_allocator(self):
        r"""get_allocator(TimeToDateMap self) -> std::map< double,Date >::allocator_type"""
        return _QuantLib.TimeToDateMap_get_allocator(self)

    def count(self, x):
        r"""count(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::size_type"""
        return _QuantLib.TimeToDateMap_count(self, x)

    def erase(self, *args):
        r"""
        erase(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::size_type
        erase(TimeToDateMap self, std::map< double,Date >::iterator position)
        erase(TimeToDateMap self, std::map< double,Date >::iterator first, std::map< double,Date >::iterator last)
        """
        return _QuantLib.TimeToDateMap_erase(self, *args)

    def find(self, x):
        r"""find(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::iterator"""
        return _QuantLib.TimeToDateMap_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::iterator"""
        return _QuantLib.TimeToDateMap_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::iterator"""
        return _QuantLib.TimeToDateMap_upper_bound(self, x)
    __swig_destroy__ = _QuantLib.delete_TimeToDateMap

# Register TimeToDateMap in _QuantLib:
_QuantLib.TimeToDateMap_swigregister(TimeToDateMap)
class FdmAffineG2ModelSwapInnerValue(FdmInnerValueCalculator):
    r"""Proxy of C++ FdmAffineModelSwapInnerValue< G2 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, disModel, fwdModel, swap, exerciseDates, mesher, direction):
        r"""__init__(FdmAffineG2ModelSwapInnerValue self, ext::shared_ptr< G2 > const & disModel, ext::shared_ptr< G2 > const & fwdModel, ext::shared_ptr< VanillaSwap > const & swap, TimeToDateMap exerciseDates, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmAffineG2ModelSwapInnerValue"""
        _QuantLib.FdmAffineG2ModelSwapInnerValue_swiginit(self, _QuantLib.new_FdmAffineG2ModelSwapInnerValue(disModel, fwdModel, swap, exerciseDates, mesher, direction))
    __swig_destroy__ = _QuantLib.delete_FdmAffineG2ModelSwapInnerValue

# Register FdmAffineG2ModelSwapInnerValue in _QuantLib:
_QuantLib.FdmAffineG2ModelSwapInnerValue_swigregister(FdmAffineG2ModelSwapInnerValue)
class FdmAffineHullWhiteModelSwapInnerValue(FdmInnerValueCalculator):
    r"""Proxy of C++ FdmAffineModelSwapInnerValue< HullWhite > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, disModel, fwdModel, swap, exerciseDates, mesher, direction):
        r"""__init__(FdmAffineHullWhiteModelSwapInnerValue self, ext::shared_ptr< HullWhite > const & disModel, ext::shared_ptr< HullWhite > const & fwdModel, ext::shared_ptr< VanillaSwap > const & swap, TimeToDateMap exerciseDates, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmAffineHullWhiteModelSwapInnerValue"""
        _QuantLib.FdmAffineHullWhiteModelSwapInnerValue_swiginit(self, _QuantLib.new_FdmAffineHullWhiteModelSwapInnerValue(disModel, fwdModel, swap, exerciseDates, mesher, direction))
    __swig_destroy__ = _QuantLib.delete_FdmAffineHullWhiteModelSwapInnerValue

# Register FdmAffineHullWhiteModelSwapInnerValue in _QuantLib:
_QuantLib.FdmAffineHullWhiteModelSwapInnerValue_swigregister(FdmAffineHullWhiteModelSwapInnerValue)
class FdmSnapshotCondition(FdmStepCondition):
    r"""Proxy of C++ FdmSnapshotCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, t):
        r"""__init__(FdmSnapshotCondition self, Time t) -> FdmSnapshotCondition"""
        _QuantLib.FdmSnapshotCondition_swiginit(self, _QuantLib.new_FdmSnapshotCondition(t))

    def getTime(self):
        r"""getTime(FdmSnapshotCondition self) -> Time"""
        return _QuantLib.FdmSnapshotCondition_getTime(self)

    def getValues(self):
        r"""getValues(FdmSnapshotCondition self) -> Array"""
        return _QuantLib.FdmSnapshotCondition_getValues(self)
    __swig_destroy__ = _QuantLib.delete_FdmSnapshotCondition

# Register FdmSnapshotCondition in _QuantLib:
_QuantLib.FdmSnapshotCondition_swigregister(FdmSnapshotCondition)
class FdmStepConditionVector(object):
    r"""Proxy of C++ std::vector< ext::shared_ptr< StepCondition< Array > > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(FdmStepConditionVector self) -> SwigPyIterator"""
        return _QuantLib.FdmStepConditionVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(FdmStepConditionVector self) -> bool"""
        return _QuantLib.FdmStepConditionVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(FdmStepConditionVector self) -> bool"""
        return _QuantLib.FdmStepConditionVector___bool__(self)

    def __len__(self):
        r"""__len__(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type"""
        return _QuantLib.FdmStepConditionVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j) -> FdmStepConditionVector"""
        return _QuantLib.FdmStepConditionVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j)
        __setslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j, FdmStepConditionVector v)
        """
        return _QuantLib.FdmStepConditionVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j)"""
        return _QuantLib.FdmStepConditionVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i)
        __delitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _QuantLib.FdmStepConditionVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice) -> FdmStepConditionVector
        __getitem__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &
        """
        return _QuantLib.FdmStepConditionVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice, FdmStepConditionVector v)
        __setitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)
        """
        return _QuantLib.FdmStepConditionVector___setitem__(self, *args)

    def pop(self):
        r"""pop(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type"""
        return _QuantLib.FdmStepConditionVector_pop(self)

    def append(self, x):
        r"""append(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)"""
        return _QuantLib.FdmStepConditionVector_append(self, x)

    def empty(self):
        r"""empty(FdmStepConditionVector self) -> bool"""
        return _QuantLib.FdmStepConditionVector_empty(self)

    def size(self):
        r"""size(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type"""
        return _QuantLib.FdmStepConditionVector_size(self)

    def swap(self, v):
        r"""swap(FdmStepConditionVector self, FdmStepConditionVector v)"""
        return _QuantLib.FdmStepConditionVector_swap(self, v)

    def begin(self):
        r"""begin(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator"""
        return _QuantLib.FdmStepConditionVector_begin(self)

    def end(self):
        r"""end(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator"""
        return _QuantLib.FdmStepConditionVector_end(self)

    def rbegin(self):
        r"""rbegin(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator"""
        return _QuantLib.FdmStepConditionVector_rbegin(self)

    def rend(self):
        r"""rend(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator"""
        return _QuantLib.FdmStepConditionVector_rend(self)

    def clear(self):
        r"""clear(FdmStepConditionVector self)"""
        return _QuantLib.FdmStepConditionVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::allocator_type"""
        return _QuantLib.FdmStepConditionVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(FdmStepConditionVector self)"""
        return _QuantLib.FdmStepConditionVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator
        erase(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator first, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator last) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator
        """
        return _QuantLib.FdmStepConditionVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FdmStepConditionVector self) -> FdmStepConditionVector
        __init__(FdmStepConditionVector self, FdmStepConditionVector other) -> FdmStepConditionVector
        __init__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type size) -> FdmStepConditionVector
        __init__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type size, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & value) -> FdmStepConditionVector
        """
        _QuantLib.FdmStepConditionVector_swiginit(self, _QuantLib.new_FdmStepConditionVector(*args))

    def push_back(self, x):
        r"""push_back(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)"""
        return _QuantLib.FdmStepConditionVector_push_back(self, x)

    def front(self):
        r"""front(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &"""
        return _QuantLib.FdmStepConditionVector_front(self)

    def back(self):
        r"""back(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &"""
        return _QuantLib.FdmStepConditionVector_back(self)

    def assign(self, n, x):
        r"""assign(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)"""
        return _QuantLib.FdmStepConditionVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type new_size)
        resize(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type new_size, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)
        """
        return _QuantLib.FdmStepConditionVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator
        insert(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)
        """
        return _QuantLib.FdmStepConditionVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n)"""
        return _QuantLib.FdmStepConditionVector_reserve(self, n)

    def capacity(self):
        r"""capacity(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type"""
        return _QuantLib.FdmStepConditionVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_FdmStepConditionVector

# Register FdmStepConditionVector in _QuantLib:
_QuantLib.FdmStepConditionVector_swigregister(FdmStepConditionVector)
class FdmStepConditionComposite(FdmStepCondition):
    r"""Proxy of C++ FdmStepConditionComposite class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, stoppingTimes, conditions):
        r"""__init__(FdmStepConditionComposite self, DoubleVector stoppingTimes, FdmStepConditionVector conditions) -> FdmStepConditionComposite"""
        _QuantLib.FdmStepConditionComposite_swiginit(self, _QuantLib.new_FdmStepConditionComposite(stoppingTimes, conditions))

    def stoppingTimes(self):
        r"""stoppingTimes(FdmStepConditionComposite self) -> DoubleVector"""
        return _QuantLib.FdmStepConditionComposite_stoppingTimes(self)

    def conditions(self):
        r"""conditions(FdmStepConditionComposite self) -> FdmStepConditionVector"""
        return _QuantLib.FdmStepConditionComposite_conditions(self)

    @staticmethod
    def joinConditions(c1, c2):
        r"""joinConditions(ext::shared_ptr< FdmSnapshotCondition > const & c1, ext::shared_ptr< FdmStepConditionComposite > const & c2) -> ext::shared_ptr< FdmStepConditionComposite >"""
        return _QuantLib.FdmStepConditionComposite_joinConditions(c1, c2)

    @staticmethod
    def vanillaComposite(schedule, exercise, mesher, calculator, refDate, dayCounter):
        r"""vanillaComposite(DividendSchedule schedule, ext::shared_ptr< Exercise > const & exercise, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Date refDate, DayCounter dayCounter) -> ext::shared_ptr< FdmStepConditionComposite >"""
        return _QuantLib.FdmStepConditionComposite_vanillaComposite(schedule, exercise, mesher, calculator, refDate, dayCounter)
    __swig_destroy__ = _QuantLib.delete_FdmStepConditionComposite

# Register FdmStepConditionComposite in _QuantLib:
_QuantLib.FdmStepConditionComposite_swigregister(FdmStepConditionComposite)
class FdmAmericanStepCondition(FdmStepCondition):
    r"""Proxy of C++ FdmAmericanStepCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, calculator):
        r"""__init__(FdmAmericanStepCondition self, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator) -> FdmAmericanStepCondition"""
        _QuantLib.FdmAmericanStepCondition_swiginit(self, _QuantLib.new_FdmAmericanStepCondition(mesher, calculator))
    __swig_destroy__ = _QuantLib.delete_FdmAmericanStepCondition

# Register FdmAmericanStepCondition in _QuantLib:
_QuantLib.FdmAmericanStepCondition_swigregister(FdmAmericanStepCondition)
class FdmArithmeticAverageCondition(FdmStepCondition):
    r"""Proxy of C++ FdmArithmeticAverageCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, averageTimes, arg3, pastFixings, mesher, equityDirection):
        r"""__init__(FdmArithmeticAverageCondition self, DoubleVector averageTimes, Real arg3, Size pastFixings, ext::shared_ptr< FdmMesher > const & mesher, Size equityDirection) -> FdmArithmeticAverageCondition"""
        _QuantLib.FdmArithmeticAverageCondition_swiginit(self, _QuantLib.new_FdmArithmeticAverageCondition(averageTimes, arg3, pastFixings, mesher, equityDirection))
    __swig_destroy__ = _QuantLib.delete_FdmArithmeticAverageCondition

# Register FdmArithmeticAverageCondition in _QuantLib:
_QuantLib.FdmArithmeticAverageCondition_swigregister(FdmArithmeticAverageCondition)
class FdmBermudanStepCondition(FdmStepCondition):
    r"""Proxy of C++ FdmBermudanStepCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exerciseDates, referenceDate, dayCounter, mesher, calculator):
        r"""__init__(FdmBermudanStepCondition self, DateVector exerciseDates, Date referenceDate, DayCounter dayCounter, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator) -> FdmBermudanStepCondition"""
        _QuantLib.FdmBermudanStepCondition_swiginit(self, _QuantLib.new_FdmBermudanStepCondition(exerciseDates, referenceDate, dayCounter, mesher, calculator))

    def exerciseTimes(self):
        r"""exerciseTimes(FdmBermudanStepCondition self) -> DoubleVector"""
        return _QuantLib.FdmBermudanStepCondition_exerciseTimes(self)
    __swig_destroy__ = _QuantLib.delete_FdmBermudanStepCondition

# Register FdmBermudanStepCondition in _QuantLib:
_QuantLib.FdmBermudanStepCondition_swigregister(FdmBermudanStepCondition)
class FdmSimpleStorageCondition(FdmStepCondition):
    r"""Proxy of C++ FdmSimpleStorageCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exerciseTimes, mesher, calculator, changeRate):
        r"""__init__(FdmSimpleStorageCondition self, DoubleVector exerciseTimes, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Real changeRate) -> FdmSimpleStorageCondition"""
        _QuantLib.FdmSimpleStorageCondition_swiginit(self, _QuantLib.new_FdmSimpleStorageCondition(exerciseTimes, mesher, calculator, changeRate))
    __swig_destroy__ = _QuantLib.delete_FdmSimpleStorageCondition

# Register FdmSimpleStorageCondition in _QuantLib:
_QuantLib.FdmSimpleStorageCondition_swigregister(FdmSimpleStorageCondition)
class FdmSimpleSwingCondition(FdmStepCondition):
    r"""Proxy of C++ FdmSimpleSwingCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exerciseTimes, mesher, calculator, swingDirection, minExercises=0):
        r"""__init__(FdmSimpleSwingCondition self, DoubleVector exerciseTimes, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Size swingDirection, Size minExercises=0) -> FdmSimpleSwingCondition"""
        _QuantLib.FdmSimpleSwingCondition_swiginit(self, _QuantLib.new_FdmSimpleSwingCondition(exerciseTimes, mesher, calculator, swingDirection, minExercises))
    __swig_destroy__ = _QuantLib.delete_FdmSimpleSwingCondition

# Register FdmSimpleSwingCondition in _QuantLib:
_QuantLib.FdmSimpleSwingCondition_swigregister(FdmSimpleSwingCondition)
class FdmDividendHandler(FdmStepCondition):
    r"""Proxy of C++ FdmDividendHandler class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, schedule, mesher, referenceDate, dayCounter, equityDirection):
        r"""__init__(FdmDividendHandler self, DividendSchedule schedule, ext::shared_ptr< FdmMesher > const & mesher, Date referenceDate, DayCounter dayCounter, Size equityDirection) -> FdmDividendHandler"""
        _QuantLib.FdmDividendHandler_swiginit(self, _QuantLib.new_FdmDividendHandler(schedule, mesher, referenceDate, dayCounter, equityDirection))

    def dividendTimes(self):
        r"""dividendTimes(FdmDividendHandler self) -> DoubleVector"""
        return _QuantLib.FdmDividendHandler_dividendTimes(self)

    def dividendDates(self):
        r"""dividendDates(FdmDividendHandler self) -> DateVector"""
        return _QuantLib.FdmDividendHandler_dividendDates(self)

    def dividends(self):
        r"""dividends(FdmDividendHandler self) -> DoubleVector"""
        return _QuantLib.FdmDividendHandler_dividends(self)
    __swig_destroy__ = _QuantLib.delete_FdmDividendHandler

# Register FdmDividendHandler in _QuantLib:
_QuantLib.FdmDividendHandler_swigregister(FdmDividendHandler)
class FdmSolverDesc(object):
    r"""Proxy of C++ FdmSolverDesc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, bcSet, condition, calculator, maturity, timeSteps, dampingSteps):
        r"""__init__(FdmSolverDesc self, ext::shared_ptr< FdmMesher > const & mesher, FdmBoundaryConditionSet bcSet, ext::shared_ptr< FdmStepConditionComposite > const & condition, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Time maturity, Size timeSteps, Size dampingSteps) -> FdmSolverDesc"""
        _QuantLib.FdmSolverDesc_swiginit(self, _QuantLib.new_FdmSolverDesc(mesher, bcSet, condition, calculator, maturity, timeSteps, dampingSteps))

    def getMesher(self):
        r"""getMesher(FdmSolverDesc self) -> ext::shared_ptr< FdmMesher >"""
        return _QuantLib.FdmSolverDesc_getMesher(self)

    def getBcSet(self):
        r"""getBcSet(FdmSolverDesc self) -> FdmBoundaryConditionSet"""
        return _QuantLib.FdmSolverDesc_getBcSet(self)

    def getStepConditions(self):
        r"""getStepConditions(FdmSolverDesc self) -> ext::shared_ptr< FdmStepConditionComposite >"""
        return _QuantLib.FdmSolverDesc_getStepConditions(self)

    def getCalculator(self):
        r"""getCalculator(FdmSolverDesc self) -> ext::shared_ptr< FdmInnerValueCalculator >"""
        return _QuantLib.FdmSolverDesc_getCalculator(self)

    def getMaturity(self):
        r"""getMaturity(FdmSolverDesc self) -> Time"""
        return _QuantLib.FdmSolverDesc_getMaturity(self)

    def getTimeSteps(self):
        r"""getTimeSteps(FdmSolverDesc self) -> Size"""
        return _QuantLib.FdmSolverDesc_getTimeSteps(self)

    def getDampingSteps(self):
        r"""getDampingSteps(FdmSolverDesc self) -> Size"""
        return _QuantLib.FdmSolverDesc_getDampingSteps(self)
    __swig_destroy__ = _QuantLib.delete_FdmSolverDesc

# Register FdmSolverDesc in _QuantLib:
_QuantLib.FdmSolverDesc_swigregister(FdmSolverDesc)
class Fdm1DimSolver(object):
    r"""Proxy of C++ Fdm1DimSolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        r"""__init__(Fdm1DimSolver self, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm1DimSolver"""
        _QuantLib.Fdm1DimSolver_swiginit(self, _QuantLib.new_Fdm1DimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        r"""interpolateAt(Fdm1DimSolver self, Real x) -> Real"""
        return _QuantLib.Fdm1DimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        r"""thetaAt(Fdm1DimSolver self, Real x) -> Real"""
        return _QuantLib.Fdm1DimSolver_thetaAt(self, x)

    def derivativeX(self, x):
        r"""derivativeX(Fdm1DimSolver self, Real x) -> Real"""
        return _QuantLib.Fdm1DimSolver_derivativeX(self, x)

    def derivativeXX(self, x):
        r"""derivativeXX(Fdm1DimSolver self, Real x) -> Real"""
        return _QuantLib.Fdm1DimSolver_derivativeXX(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm1DimSolver

# Register Fdm1DimSolver in _QuantLib:
_QuantLib.Fdm1DimSolver_swigregister(Fdm1DimSolver)
class FdmBackwardSolver(object):
    r"""Proxy of C++ FdmBackwardSolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, map, bcSet, condition, schemeDesc):
        r"""__init__(FdmBackwardSolver self, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet, ext::shared_ptr< FdmStepConditionComposite > const condition, FdmSchemeDesc schemeDesc) -> FdmBackwardSolver"""
        _QuantLib.FdmBackwardSolver_swiginit(self, _QuantLib.new_FdmBackwardSolver(map, bcSet, condition, schemeDesc))

    def rollback(self, a, _from, to, steps, dampingSteps):
        r"""rollback(FdmBackwardSolver self, Array a, Time _from, Time to, Size steps, Size dampingSteps)"""
        return _QuantLib.FdmBackwardSolver_rollback(self, a, _from, to, steps, dampingSteps)
    __swig_destroy__ = _QuantLib.delete_FdmBackwardSolver

# Register FdmBackwardSolver in _QuantLib:
_QuantLib.FdmBackwardSolver_swigregister(FdmBackwardSolver)
class Fdm2dBlackScholesSolver(object):
    r"""Proxy of C++ Fdm2dBlackScholesSolver class."""

    thisown = 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):
        r"""__init__(Fdm2dBlackScholesSolver self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p2, Real const correlation, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >()) -> Fdm2dBlackScholesSolver"""
        _QuantLib.Fdm2dBlackScholesSolver_swiginit(self, _QuantLib.new_Fdm2dBlackScholesSolver(*args, **kwargs))

    def valueAt(self, x, y):
        r"""valueAt(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_valueAt(self, x, y)

    def thetaAt(self, x, y):
        r"""thetaAt(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_thetaAt(self, x, y)

    def deltaXat(self, x, y):
        r"""deltaXat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_deltaXat(self, x, y)

    def deltaYat(self, x, y):
        r"""deltaYat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_deltaYat(self, x, y)

    def gammaXat(self, x, y):
        r"""gammaXat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_gammaXat(self, x, y)

    def gammaYat(self, x, y):
        r"""gammaYat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_gammaYat(self, x, y)

    def gammaXYat(self, x, y):
        r"""gammaXYat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2dBlackScholesSolver_gammaXYat(self, x, y)
    __swig_destroy__ = _QuantLib.delete_Fdm2dBlackScholesSolver

# Register Fdm2dBlackScholesSolver in _QuantLib:
_QuantLib.Fdm2dBlackScholesSolver_swigregister(Fdm2dBlackScholesSolver)
class Fdm2DimSolver(object):
    r"""Proxy of C++ Fdm2DimSolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        r"""__init__(Fdm2DimSolver self, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm2DimSolver"""
        _QuantLib.Fdm2DimSolver_swiginit(self, _QuantLib.new_Fdm2DimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x, y):
        r"""interpolateAt(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_interpolateAt(self, x, y)

    def thetaAt(self, x, y):
        r"""thetaAt(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_thetaAt(self, x, y)

    def derivativeX(self, x, y):
        r"""derivativeX(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_derivativeX(self, x, y)

    def derivativeY(self, x, y):
        r"""derivativeY(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_derivativeY(self, x, y)

    def derivativeXX(self, x, y):
        r"""derivativeXX(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_derivativeXX(self, x, y)

    def derivativeYY(self, x, y):
        r"""derivativeYY(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_derivativeYY(self, x, y)

    def derivativeXY(self, x, y):
        r"""derivativeXY(Fdm2DimSolver self, Real x, Real y) -> Real"""
        return _QuantLib.Fdm2DimSolver_derivativeXY(self, x, y)
    __swig_destroy__ = _QuantLib.delete_Fdm2DimSolver

# Register Fdm2DimSolver in _QuantLib:
_QuantLib.Fdm2DimSolver_swigregister(Fdm2DimSolver)
class Fdm3DimSolver(object):
    r"""Proxy of C++ Fdm3DimSolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        r"""__init__(Fdm3DimSolver self, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm3DimSolver"""
        _QuantLib.Fdm3DimSolver_swiginit(self, _QuantLib.new_Fdm3DimSolver(solverDesc, schemeDesc, op))

    def performCalculations(self):
        r"""performCalculations(Fdm3DimSolver self)"""
        return _QuantLib.Fdm3DimSolver_performCalculations(self)

    def interpolateAt(self, x, y, z):
        r"""interpolateAt(Fdm3DimSolver self, Real x, Real y, Rate z) -> Real"""
        return _QuantLib.Fdm3DimSolver_interpolateAt(self, x, y, z)

    def thetaAt(self, x, y, z):
        r"""thetaAt(Fdm3DimSolver self, Real x, Real y, Rate z) -> Real"""
        return _QuantLib.Fdm3DimSolver_thetaAt(self, x, y, z)
    __swig_destroy__ = _QuantLib.delete_Fdm3DimSolver

# Register Fdm3DimSolver in _QuantLib:
_QuantLib.Fdm3DimSolver_swigregister(Fdm3DimSolver)
class FdmG2Solver(object):
    r"""Proxy of C++ FdmG2Solver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmG2Solver self, ext::shared_ptr< G2 > const & model, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdmG2Solver"""
        _QuantLib.FdmG2Solver_swiginit(self, _QuantLib.new_FdmG2Solver(*args))

    def valueAt(self, x, y):
        r"""valueAt(FdmG2Solver self, Real x, Real y) -> Real"""
        return _QuantLib.FdmG2Solver_valueAt(self, x, y)
    __swig_destroy__ = _QuantLib.delete_FdmG2Solver

# Register FdmG2Solver in _QuantLib:
_QuantLib.FdmG2Solver_swigregister(FdmG2Solver)
class FdmHestonHullWhiteSolver(object):
    r"""Proxy of C++ FdmHestonHullWhiteSolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmHestonHullWhiteSolver self, ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< HullWhiteProcess > const & hwProcess, Rate corrEquityShortRate, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdmHestonHullWhiteSolver"""
        _QuantLib.FdmHestonHullWhiteSolver_swiginit(self, _QuantLib.new_FdmHestonHullWhiteSolver(*args))

    def valueAt(self, s, v, r):
        r"""valueAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r) -> Real"""
        return _QuantLib.FdmHestonHullWhiteSolver_valueAt(self, s, v, r)

    def thetaAt(self, s, v, r):
        r"""thetaAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r) -> Real"""
        return _QuantLib.FdmHestonHullWhiteSolver_thetaAt(self, s, v, r)

    def deltaAt(self, s, v, r, eps):
        r"""deltaAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r, Real eps) -> Real"""
        return _QuantLib.FdmHestonHullWhiteSolver_deltaAt(self, s, v, r, eps)

    def gammaAt(self, s, v, r, eps):
        r"""gammaAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r, Real eps) -> Real"""
        return _QuantLib.FdmHestonHullWhiteSolver_gammaAt(self, s, v, r, eps)
    __swig_destroy__ = _QuantLib.delete_FdmHestonHullWhiteSolver

# Register FdmHestonHullWhiteSolver in _QuantLib:
_QuantLib.FdmHestonHullWhiteSolver_swigregister(FdmHestonHullWhiteSolver)
class FdmHestonSolver(object):
    r"""Proxy of C++ FdmHestonSolver class."""

    thisown = 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):
        r"""__init__(FdmHestonSolver self, ext::shared_ptr< HestonProcess > const & process, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >()) -> FdmHestonSolver"""
        _QuantLib.FdmHestonSolver_swiginit(self, _QuantLib.new_FdmHestonSolver(*args, **kwargs))

    def valueAt(self, s, v):
        r"""valueAt(FdmHestonSolver self, Real s, Real v) -> Real"""
        return _QuantLib.FdmHestonSolver_valueAt(self, s, v)

    def thetaAt(self, s, v):
        r"""thetaAt(FdmHestonSolver self, Real s, Real v) -> Real"""
        return _QuantLib.FdmHestonSolver_thetaAt(self, s, v)

    def deltaAt(self, s, v):
        r"""deltaAt(FdmHestonSolver self, Real s, Real v) -> Real"""
        return _QuantLib.FdmHestonSolver_deltaAt(self, s, v)

    def gammaAt(self, s, v):
        r"""gammaAt(FdmHestonSolver self, Real s, Real v) -> Real"""
        return _QuantLib.FdmHestonSolver_gammaAt(self, s, v)

    def meanVarianceDeltaAt(self, s, v):
        r"""meanVarianceDeltaAt(FdmHestonSolver self, Real s, Real v) -> Real"""
        return _QuantLib.FdmHestonSolver_meanVarianceDeltaAt(self, s, v)

    def meanVarianceGammaAt(self, s, v):
        r"""meanVarianceGammaAt(FdmHestonSolver self, Real s, Real v) -> Real"""
        return _QuantLib.FdmHestonSolver_meanVarianceGammaAt(self, s, v)
    __swig_destroy__ = _QuantLib.delete_FdmHestonSolver

# Register FdmHestonSolver in _QuantLib:
_QuantLib.FdmHestonSolver_swigregister(FdmHestonSolver)
class FdmHullWhiteSolver(object):
    r"""Proxy of C++ FdmHullWhiteSolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdmHullWhiteSolver self, ext::shared_ptr< HullWhite > const & model, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdmHullWhiteSolver"""
        _QuantLib.FdmHullWhiteSolver_swiginit(self, _QuantLib.new_FdmHullWhiteSolver(*args))

    def valueAt(self, r):
        r"""valueAt(FdmHullWhiteSolver self, Real r) -> Real"""
        return _QuantLib.FdmHullWhiteSolver_valueAt(self, r)
    __swig_destroy__ = _QuantLib.delete_FdmHullWhiteSolver

# Register FdmHullWhiteSolver in _QuantLib:
_QuantLib.FdmHullWhiteSolver_swigregister(FdmHullWhiteSolver)
class Fdm4dimSolver(object):
    r"""Proxy of C++ FdmNdimSolver< 4 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        r"""__init__(Fdm4dimSolver self, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm4dimSolver"""
        _QuantLib.Fdm4dimSolver_swiginit(self, _QuantLib.new_Fdm4dimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        r"""interpolateAt(Fdm4dimSolver self, DoubleVector x) -> Real"""
        return _QuantLib.Fdm4dimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        r"""thetaAt(Fdm4dimSolver self, DoubleVector x) -> Real"""
        return _QuantLib.Fdm4dimSolver_thetaAt(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm4dimSolver

# Register Fdm4dimSolver in _QuantLib:
_QuantLib.Fdm4dimSolver_swigregister(Fdm4dimSolver)
class Fdm5dimSolver(object):
    r"""Proxy of C++ FdmNdimSolver< 5 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        r"""__init__(Fdm5dimSolver self, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm5dimSolver"""
        _QuantLib.Fdm5dimSolver_swiginit(self, _QuantLib.new_Fdm5dimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        r"""interpolateAt(Fdm5dimSolver self, DoubleVector x) -> Real"""
        return _QuantLib.Fdm5dimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        r"""thetaAt(Fdm5dimSolver self, DoubleVector x) -> Real"""
        return _QuantLib.Fdm5dimSolver_thetaAt(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm5dimSolver

# Register Fdm5dimSolver in _QuantLib:
_QuantLib.Fdm5dimSolver_swigregister(Fdm5dimSolver)
class Fdm6dimSolver(object):
    r"""Proxy of C++ FdmNdimSolver< 6 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        r"""__init__(Fdm6dimSolver self, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm6dimSolver"""
        _QuantLib.Fdm6dimSolver_swiginit(self, _QuantLib.new_Fdm6dimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        r"""interpolateAt(Fdm6dimSolver self, DoubleVector x) -> Real"""
        return _QuantLib.Fdm6dimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        r"""thetaAt(Fdm6dimSolver self, DoubleVector x) -> Real"""
        return _QuantLib.Fdm6dimSolver_thetaAt(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm6dimSolver

# Register Fdm6dimSolver in _QuantLib:
_QuantLib.Fdm6dimSolver_swigregister(Fdm6dimSolver)
class FdmIndicesOnBoundary(object):
    r"""Proxy of C++ FdmIndicesOnBoundary class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, l, direction, side):
        r"""__init__(FdmIndicesOnBoundary self, ext::shared_ptr< FdmLinearOpLayout > const & l, Size direction, FdmDirichletBoundary::Side side) -> FdmIndicesOnBoundary"""
        _QuantLib.FdmIndicesOnBoundary_swiginit(self, _QuantLib.new_FdmIndicesOnBoundary(l, direction, side))

    def getIndices(self):
        r"""getIndices(FdmIndicesOnBoundary self) -> UnsignedIntVector"""
        return _QuantLib.FdmIndicesOnBoundary_getIndices(self)
    __swig_destroy__ = _QuantLib.delete_FdmIndicesOnBoundary

# Register FdmIndicesOnBoundary in _QuantLib:
_QuantLib.FdmIndicesOnBoundary_swigregister(FdmIndicesOnBoundary)
class RiskNeutralDensityCalculator(object):
    r"""Proxy of C++ RiskNeutralDensityCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def pdf(self, x, t):
        r"""pdf(RiskNeutralDensityCalculator self, Real x, Time t) -> Real"""
        return _QuantLib.RiskNeutralDensityCalculator_pdf(self, x, t)

    def cdf(self, x, t):
        r"""cdf(RiskNeutralDensityCalculator self, Real x, Time t) -> Real"""
        return _QuantLib.RiskNeutralDensityCalculator_cdf(self, x, t)

    def invcdf(self, p, t):
        r"""invcdf(RiskNeutralDensityCalculator self, Real p, Time t) -> Real"""
        return _QuantLib.RiskNeutralDensityCalculator_invcdf(self, p, t)
    __swig_destroy__ = _QuantLib.delete_RiskNeutralDensityCalculator

# Register RiskNeutralDensityCalculator in _QuantLib:
_QuantLib.RiskNeutralDensityCalculator_swigregister(RiskNeutralDensityCalculator)
class BSMRNDCalculator(RiskNeutralDensityCalculator):
    r"""Proxy of C++ BSMRNDCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        r"""__init__(BSMRNDCalculator self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> BSMRNDCalculator"""
        _QuantLib.BSMRNDCalculator_swiginit(self, _QuantLib.new_BSMRNDCalculator(process))
    __swig_destroy__ = _QuantLib.delete_BSMRNDCalculator

# Register BSMRNDCalculator in _QuantLib:
_QuantLib.BSMRNDCalculator_swigregister(BSMRNDCalculator)
class CEVRNDCalculator(RiskNeutralDensityCalculator):
    r"""Proxy of C++ CEVRNDCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, f0, alpha, beta):
        r"""__init__(CEVRNDCalculator self, Real f0, Real alpha, Real beta) -> CEVRNDCalculator"""
        _QuantLib.CEVRNDCalculator_swiginit(self, _QuantLib.new_CEVRNDCalculator(f0, alpha, beta))

    def massAtZero(self, t):
        r"""massAtZero(CEVRNDCalculator self, Time t) -> Real"""
        return _QuantLib.CEVRNDCalculator_massAtZero(self, t)
    __swig_destroy__ = _QuantLib.delete_CEVRNDCalculator

# Register CEVRNDCalculator in _QuantLib:
_QuantLib.CEVRNDCalculator_swigregister(CEVRNDCalculator)
class GBSMRNDCalculator(RiskNeutralDensityCalculator):
    r"""Proxy of C++ GBSMRNDCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        r"""__init__(GBSMRNDCalculator self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> GBSMRNDCalculator"""
        _QuantLib.GBSMRNDCalculator_swiginit(self, _QuantLib.new_GBSMRNDCalculator(process))
    __swig_destroy__ = _QuantLib.delete_GBSMRNDCalculator

# Register GBSMRNDCalculator in _QuantLib:
_QuantLib.GBSMRNDCalculator_swigregister(GBSMRNDCalculator)
class HestonRNDCalculator(RiskNeutralDensityCalculator):
    r"""Proxy of C++ HestonRNDCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, hestonProcess, integrationEps=1e-6, maxIntegrationIterations=10000):
        r"""__init__(HestonRNDCalculator self, ext::shared_ptr< HestonProcess > const & hestonProcess, Real integrationEps=1e-6, Size maxIntegrationIterations=10000) -> HestonRNDCalculator"""
        _QuantLib.HestonRNDCalculator_swiginit(self, _QuantLib.new_HestonRNDCalculator(hestonProcess, integrationEps, maxIntegrationIterations))
    __swig_destroy__ = _QuantLib.delete_HestonRNDCalculator

# Register HestonRNDCalculator in _QuantLib:
_QuantLib.HestonRNDCalculator_swigregister(HestonRNDCalculator)
class LocalVolRNDCalculator(RiskNeutralDensityCalculator):
    r"""Proxy of C++ LocalVolRNDCalculator class."""

    thisown = 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):
        r"""__init__(LocalVolRNDCalculator self, ext::shared_ptr< Quote > const & spot, ext::shared_ptr< YieldTermStructure > const & rTS, ext::shared_ptr< YieldTermStructure > const & qTS, ext::shared_ptr< LocalVolTermStructure > const & localVol, Size xGrid=101, Size tGrid=51, Real x0Density=0.1, Real localVolProbEps=1e-6, Size maxIter=10000, Time gaussianStepSize=-Null< Time >()) -> LocalVolRNDCalculator"""
        _QuantLib.LocalVolRNDCalculator_swiginit(self, _QuantLib.new_LocalVolRNDCalculator(*args, **kwargs))

    def mesher(self, t):
        r"""mesher(LocalVolRNDCalculator self, Time t) -> ext::shared_ptr< Fdm1dMesher >"""
        return _QuantLib.LocalVolRNDCalculator_mesher(self, t)

    def rescaleTimeSteps(self):
        r"""rescaleTimeSteps(LocalVolRNDCalculator self) -> UnsignedIntVector"""
        return _QuantLib.LocalVolRNDCalculator_rescaleTimeSteps(self)
    __swig_destroy__ = _QuantLib.delete_LocalVolRNDCalculator

# Register LocalVolRNDCalculator in _QuantLib:
_QuantLib.LocalVolRNDCalculator_swigregister(LocalVolRNDCalculator)
class SquareRootProcessRNDCalculator(RiskNeutralDensityCalculator):
    r"""Proxy of C++ SquareRootProcessRNDCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, v0, kappa, theta, sigma):
        r"""__init__(SquareRootProcessRNDCalculator self, Real v0, Real kappa, Real theta, Real sigma) -> SquareRootProcessRNDCalculator"""
        _QuantLib.SquareRootProcessRNDCalculator_swiginit(self, _QuantLib.new_SquareRootProcessRNDCalculator(v0, kappa, theta, sigma))

    def stationary_pdf(self, v):
        r"""stationary_pdf(SquareRootProcessRNDCalculator self, Real v) -> Real"""
        return _QuantLib.SquareRootProcessRNDCalculator_stationary_pdf(self, v)

    def stationary_cdf(self, v):
        r"""stationary_cdf(SquareRootProcessRNDCalculator self, Real v) -> Real"""
        return _QuantLib.SquareRootProcessRNDCalculator_stationary_cdf(self, v)

    def stationary_invcdf(self, q):
        r"""stationary_invcdf(SquareRootProcessRNDCalculator self, Real q) -> Real"""
        return _QuantLib.SquareRootProcessRNDCalculator_stationary_invcdf(self, q)
    __swig_destroy__ = _QuantLib.delete_SquareRootProcessRNDCalculator

# Register SquareRootProcessRNDCalculator in _QuantLib:
_QuantLib.SquareRootProcessRNDCalculator_swigregister(SquareRootProcessRNDCalculator)
class FittingMethod(object):
    r"""Proxy of C++ FittingMethod class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_FittingMethod

    def size(self):
        r"""size(FittingMethod self) -> Size"""
        return _QuantLib.FittingMethod_size(self)

    def solution(self):
        r"""solution(FittingMethod self) -> Array"""
        return _QuantLib.FittingMethod_solution(self)

    def numberOfIterations(self):
        r"""numberOfIterations(FittingMethod self) -> Integer"""
        return _QuantLib.FittingMethod_numberOfIterations(self)

    def minimumCostValue(self):
        r"""minimumCostValue(FittingMethod self) -> Real"""
        return _QuantLib.FittingMethod_minimumCostValue(self)

    def constrainAtZero(self):
        r"""constrainAtZero(FittingMethod self) -> bool"""
        return _QuantLib.FittingMethod_constrainAtZero(self)

    def weights(self):
        r"""weights(FittingMethod self) -> Array"""
        return _QuantLib.FittingMethod_weights(self)

# Register FittingMethod in _QuantLib:
_QuantLib.FittingMethod_swigregister(FittingMethod)
class FittedBondDiscountCurve(YieldTermStructure):
    r"""Proxy of C++ FittedBondDiscountCurve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(FittedBondDiscountCurve self, Natural settlementDays, Calendar calendar, BondHelperVector helpers, DayCounter dayCounter, FittingMethod fittingMethod, Real accuracy=1.0e-10, Size maxEvaluations=10000, Array guess=Array(), Real simplexLambda=1.0) -> FittedBondDiscountCurve
        __init__(FittedBondDiscountCurve self, Date referenceDate, BondHelperVector helpers, DayCounter dayCounter, FittingMethod fittingMethod, Real accuracy=1.0e-10, Size maxEvaluations=10000, Array guess=Array(), Real simplexLambda=1.0) -> FittedBondDiscountCurve
        """
        _QuantLib.FittedBondDiscountCurve_swiginit(self, _QuantLib.new_FittedBondDiscountCurve(*args))

    def fitResults(self):
        r"""fitResults(FittedBondDiscountCurve self) -> FittingMethod"""
        return _QuantLib.FittedBondDiscountCurve_fitResults(self)
    __swig_destroy__ = _QuantLib.delete_FittedBondDiscountCurve

# Register FittedBondDiscountCurve in _QuantLib:
_QuantLib.FittedBondDiscountCurve_swigregister(FittedBondDiscountCurve)
class ExponentialSplinesFitting(FittingMethod):
    r"""Proxy of C++ ExponentialSplinesFitting class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ExponentialSplinesFitting self, bool constrainAtZero=True, Array weights=Array(), Array l2=Array(), Real minCutoffTime=0.0, Real maxCutoffTime=QL_MAX_REAL, Size numCoeffs=9, Real fixedKappa=Null< Real >()) -> ExponentialSplinesFitting"""
        _QuantLib.ExponentialSplinesFitting_swiginit(self, _QuantLib.new_ExponentialSplinesFitting(*args))
    __swig_destroy__ = _QuantLib.delete_ExponentialSplinesFitting

# Register ExponentialSplinesFitting in _QuantLib:
_QuantLib.ExponentialSplinesFitting_swigregister(ExponentialSplinesFitting)
class NelsonSiegelFitting(FittingMethod):
    r"""Proxy of C++ NelsonSiegelFitting class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NelsonSiegelFitting self, Array weights=Array()) -> NelsonSiegelFitting"""
        _QuantLib.NelsonSiegelFitting_swiginit(self, _QuantLib.new_NelsonSiegelFitting(*args))
    __swig_destroy__ = _QuantLib.delete_NelsonSiegelFitting

# Register NelsonSiegelFitting in _QuantLib:
_QuantLib.NelsonSiegelFitting_swigregister(NelsonSiegelFitting)
class SvenssonFitting(FittingMethod):
    r"""Proxy of C++ SvenssonFitting class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(SvenssonFitting self, Array weights=Array()) -> SvenssonFitting"""
        _QuantLib.SvenssonFitting_swiginit(self, _QuantLib.new_SvenssonFitting(*args))
    __swig_destroy__ = _QuantLib.delete_SvenssonFitting

# Register SvenssonFitting in _QuantLib:
_QuantLib.SvenssonFitting_swigregister(SvenssonFitting)
class CubicBSplinesFitting(FittingMethod):
    r"""Proxy of C++ CubicBSplinesFitting class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(CubicBSplinesFitting self, DoubleVector knotVector, bool constrainAtZero=True, Array weights=Array()) -> CubicBSplinesFitting"""
        _QuantLib.CubicBSplinesFitting_swiginit(self, _QuantLib.new_CubicBSplinesFitting(*args))

    def basisFunction(self, i, t):
        r"""basisFunction(CubicBSplinesFitting self, Integer i, Time t) -> Real"""
        return _QuantLib.CubicBSplinesFitting_basisFunction(self, i, t)
    __swig_destroy__ = _QuantLib.delete_CubicBSplinesFitting

# Register CubicBSplinesFitting in _QuantLib:
_QuantLib.CubicBSplinesFitting_swigregister(CubicBSplinesFitting)
class SimplePolynomialFitting(FittingMethod):
    r"""Proxy of C++ SimplePolynomialFitting class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(SimplePolynomialFitting self, Natural degree, bool constrainAtZero=True, Array weights=Array()) -> SimplePolynomialFitting"""
        _QuantLib.SimplePolynomialFitting_swiginit(self, _QuantLib.new_SimplePolynomialFitting(*args))
    __swig_destroy__ = _QuantLib.delete_SimplePolynomialFitting

# Register SimplePolynomialFitting in _QuantLib:
_QuantLib.SimplePolynomialFitting_swigregister(SimplePolynomialFitting)
class SpreadFittingMethod(FittingMethod):
    r"""Proxy of C++ SpreadFittingMethod class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(SpreadFittingMethod self, ext::shared_ptr< FittingMethod > const & method, YieldTermStructureHandle discountCurve, Real minCutoffTime=0.0, Real maxCutoffTime=QL_MAX_REAL) -> SpreadFittingMethod"""
        _QuantLib.SpreadFittingMethod_swiginit(self, _QuantLib.new_SpreadFittingMethod(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadFittingMethod

# Register SpreadFittingMethod in _QuantLib:
_QuantLib.SpreadFittingMethod_swigregister(SpreadFittingMethod)
class ForwardCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedForwardCurve< BackwardFlat > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ForwardCurve self, DateVector dates, DoubleVector forwards, DayCounter dayCounter, Calendar calendar=Calendar(), BackwardFlat i=BackwardFlat()) -> ForwardCurve"""
        _QuantLib.ForwardCurve_swiginit(self, _QuantLib.new_ForwardCurve(*args))

    def dates(self):
        r"""dates(ForwardCurve self) -> DateVector"""
        return _QuantLib.ForwardCurve_dates(self)

    def forwards(self):
        r"""forwards(ForwardCurve self) -> DoubleVector"""
        return _QuantLib.ForwardCurve_forwards(self)

    def nodes(self):
        r"""nodes(ForwardCurve self) -> NodeVector"""
        return _QuantLib.ForwardCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ForwardCurve

# Register ForwardCurve in _QuantLib:
_QuantLib.ForwardCurve_swigregister(ForwardCurve)
class Position(object):
    r"""Proxy of C++ Position class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Long = _QuantLib.Position_Long
    
    Short = _QuantLib.Position_Short
    

    def __init__(self):
        r"""__init__(Position self) -> Position"""
        _QuantLib.Position_swiginit(self, _QuantLib.new_Position())
    __swig_destroy__ = _QuantLib.delete_Position

# Register Position in _QuantLib:
_QuantLib.Position_swigregister(Position)
class ForwardRateAgreement(Instrument):
    r"""Proxy of C++ ForwardRateAgreement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ForwardRateAgreement self, Date valueDate, Date maturityDate, Position::Type type, Rate strikeForwardRate, Real notionalAmount, ext::shared_ptr< IborIndex > const & index, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), bool useIndexedCoupon=True) -> ForwardRateAgreement
        __init__(ForwardRateAgreement self, Date valueDate, Position::Type type, Rate strikeForwardRate, Real notionalAmount, ext::shared_ptr< IborIndex > const & index, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >()) -> ForwardRateAgreement
        """
        _QuantLib.ForwardRateAgreement_swiginit(self, _QuantLib.new_ForwardRateAgreement(*args))

    def amount(self):
        r"""amount(ForwardRateAgreement self) -> Real"""
        return _QuantLib.ForwardRateAgreement_amount(self)

    def fixingDate(self):
        r"""fixingDate(ForwardRateAgreement self) -> Date"""
        return _QuantLib.ForwardRateAgreement_fixingDate(self)

    def forwardRate(self):
        r"""forwardRate(ForwardRateAgreement self) -> InterestRate"""
        return _QuantLib.ForwardRateAgreement_forwardRate(self)

    def spotIncome(self, discount):
        r"""spotIncome(ForwardRateAgreement self, YieldTermStructureHandle discount) -> Real"""
        return _QuantLib.ForwardRateAgreement_spotIncome(self, discount)

    def spotValue(self):
        r"""spotValue(ForwardRateAgreement self) -> Real"""
        return _QuantLib.ForwardRateAgreement_spotValue(self)
    __swig_destroy__ = _QuantLib.delete_ForwardRateAgreement

# Register ForwardRateAgreement in _QuantLib:
_QuantLib.ForwardRateAgreement_swigregister(ForwardRateAgreement)
class Gaussian1dModel(TermStructureConsistentModel):
    r"""Proxy of C++ Gaussian1dModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def stateProcess(self):
        r"""stateProcess(Gaussian1dModel self) -> ext::shared_ptr< StochasticProcess1D > const"""
        return _QuantLib.Gaussian1dModel_stateProcess(self)

    def numeraire(self, *args):
        r"""
        numeraire(Gaussian1dModel self, Time const t, Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const
        numeraire(Gaussian1dModel self, Date referenceDate, Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const
        """
        return _QuantLib.Gaussian1dModel_numeraire(self, *args)

    def zerobond(self, *args):
        r"""
        zerobond(Gaussian1dModel self, Time const T, Time const t=0.0, Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const
        zerobond(Gaussian1dModel self, Date maturity, Date referenceDate=Null< Date >(), Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const
        """
        return _QuantLib.Gaussian1dModel_zerobond(self, *args)

    def zerobondOption(self, *args):
        r"""zerobondOption(Gaussian1dModel self, Option::Type const & type, Date expiry, Date valueDate, Date maturity, Rate const strike, Date referenceDate=Null< Date >(), Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >(), Real const yStdDevs=7.0, Size const yGridPoints=64, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False) -> Real const"""
        return _QuantLib.Gaussian1dModel_zerobondOption(self, *args)

    def forwardRate(self, *args):
        r"""forwardRate(Gaussian1dModel self, Date fixing, Date referenceDate=Null< Date >(), Real const y=0.0, ext::shared_ptr< IborIndex > iborIdx=ext::shared_ptr< IborIndex >()) -> Real const"""
        return _QuantLib.Gaussian1dModel_forwardRate(self, *args)

    def swapRate(self, *args):
        r"""swapRate(Gaussian1dModel self, Date fixing, Period tenor, Date referenceDate=Null< Date >(), Real const y=0.0, ext::shared_ptr< SwapIndex > swapIdx=ext::shared_ptr< SwapIndex >()) -> Real const"""
        return _QuantLib.Gaussian1dModel_swapRate(self, *args)

    def swapAnnuity(self, *args):
        r"""swapAnnuity(Gaussian1dModel self, Date fixing, Period tenor, Date referenceDate=Null< Date >(), Real const y=0.0, ext::shared_ptr< SwapIndex > swapIdx=ext::shared_ptr< SwapIndex >()) -> Real const"""
        return _QuantLib.Gaussian1dModel_swapAnnuity(self, *args)
    __swig_destroy__ = _QuantLib.delete_Gaussian1dModel

# Register Gaussian1dModel in _QuantLib:
_QuantLib.Gaussian1dModel_swigregister(Gaussian1dModel)
class Gsr(Gaussian1dModel):
    r"""Proxy of C++ Gsr class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, termStructure, volstepdates, volatilities, reversions, T=60.0):
        r"""__init__(Gsr self, YieldTermStructureHandle termStructure, DateVector volstepdates, QuoteHandleVector volatilities, QuoteHandleVector reversions, Real const T=60.0) -> Gsr"""
        _QuantLib.Gsr_swiginit(self, _QuantLib.new_Gsr(termStructure, volstepdates, volatilities, reversions, T))

    def calibrateVolatilitiesIterative(self, *args):
        r"""calibrateVolatilitiesIterative(Gsr self, BlackCalibrationHelperVector helpers, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >())"""
        return _QuantLib.Gsr_calibrateVolatilitiesIterative(self, *args)

    def reversion(self):
        r"""reversion(Gsr self) -> Array"""
        return _QuantLib.Gsr_reversion(self)

    def volatility(self):
        r"""volatility(Gsr self) -> Array"""
        return _QuantLib.Gsr_volatility(self)

    def params(self):
        r"""params(Gsr self) -> Array"""
        return _QuantLib.Gsr_params(self)

    def calibrate(self, *args):
        r"""calibrate(Gsr self, CalibrationHelperVector instruments, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"""
        return _QuantLib.Gsr_calibrate(self, *args)

    def setParams(self, params):
        r"""setParams(Gsr self, Array params)"""
        return _QuantLib.Gsr_setParams(self, params)

    def value(self, params, instruments):
        r"""value(Gsr self, Array params, CalibrationHelperVector instruments) -> Real"""
        return _QuantLib.Gsr_value(self, params, instruments)

    def constraint(self):
        r"""constraint(Gsr self) -> ext::shared_ptr< Constraint > const &"""
        return _QuantLib.Gsr_constraint(self)

    def endCriteria(self):
        r"""endCriteria(Gsr self) -> EndCriteria::Type"""
        return _QuantLib.Gsr_endCriteria(self)

    def problemValues(self):
        r"""problemValues(Gsr self) -> Array"""
        return _QuantLib.Gsr_problemValues(self)

    def functionEvaluation(self):
        r"""functionEvaluation(Gsr self) -> Integer"""
        return _QuantLib.Gsr_functionEvaluation(self)
    __swig_destroy__ = _QuantLib.delete_Gsr

# Register Gsr in _QuantLib:
_QuantLib.Gsr_swigregister(Gsr)
class MarkovFunctional(Gaussian1dModel):
    r"""Proxy of C++ MarkovFunctional class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MarkovFunctional self, YieldTermStructureHandle termStructure, Real const reversion, DateVector volstepdates, DoubleVector volatilities, SwaptionVolatilityStructureHandle swaptionVol, DateVector swaptionExpiries, PeriodVector swaptionTenors, ext::shared_ptr< SwapIndex > const & swapIndexBase, MarkovFunctionalSettings modelSettings=MarkovFunctional::ModelSettings()) -> MarkovFunctional
        __init__(MarkovFunctional self, YieldTermStructureHandle termStructure, Real const reversion, DateVector volstepdates, DoubleVector volatilities, OptionletVolatilityStructureHandle capletVol, DateVector capletExpiries, ext::shared_ptr< IborIndex > const & iborIndex, MarkovFunctionalSettings modelSettings=MarkovFunctional::ModelSettings()) -> MarkovFunctional
        """
        _QuantLib.MarkovFunctional_swiginit(self, _QuantLib.new_MarkovFunctional(*args))

    def volatility(self):
        r"""volatility(MarkovFunctional self) -> Array"""
        return _QuantLib.MarkovFunctional_volatility(self)

    def calibrate(self, *args):
        r"""calibrate(MarkovFunctional self, CalibrationHelperVector helper, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"""
        return _QuantLib.MarkovFunctional_calibrate(self, *args)

    def params(self):
        r"""params(MarkovFunctional self) -> Array"""
        return _QuantLib.MarkovFunctional_params(self)

    def setParams(self, params):
        r"""setParams(MarkovFunctional self, Array params)"""
        return _QuantLib.MarkovFunctional_setParams(self, params)

    def value(self, params, instruments):
        r"""value(MarkovFunctional self, Array params, CalibrationHelperVector instruments) -> Real"""
        return _QuantLib.MarkovFunctional_value(self, params, instruments)

    def constraint(self):
        r"""constraint(MarkovFunctional self) -> ext::shared_ptr< Constraint > const &"""
        return _QuantLib.MarkovFunctional_constraint(self)

    def endCriteria(self):
        r"""endCriteria(MarkovFunctional self) -> EndCriteria::Type"""
        return _QuantLib.MarkovFunctional_endCriteria(self)

    def problemValues(self):
        r"""problemValues(MarkovFunctional self) -> Array"""
        return _QuantLib.MarkovFunctional_problemValues(self)

    def functionEvaluation(self):
        r"""functionEvaluation(MarkovFunctional self) -> Integer"""
        return _QuantLib.MarkovFunctional_functionEvaluation(self)
    __swig_destroy__ = _QuantLib.delete_MarkovFunctional

# Register MarkovFunctional in _QuantLib:
_QuantLib.MarkovFunctional_swigregister(MarkovFunctional)
class MarkovFunctionalSettings(object):
    r"""Proxy of C++ MarkovFunctional::ModelSettings class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AdjustNone = _QuantLib.MarkovFunctionalSettings_AdjustNone
    
    AdjustDigitals = _QuantLib.MarkovFunctionalSettings_AdjustDigitals
    
    AdjustYts = _QuantLib.MarkovFunctionalSettings_AdjustYts
    
    ExtrapolatePayoffFlat = _QuantLib.MarkovFunctionalSettings_ExtrapolatePayoffFlat
    
    NoPayoffExtrapolation = _QuantLib.MarkovFunctionalSettings_NoPayoffExtrapolation
    
    KahaleSmile = _QuantLib.MarkovFunctionalSettings_KahaleSmile
    
    SmileExponentialExtrapolation = _QuantLib.MarkovFunctionalSettings_SmileExponentialExtrapolation
    
    KahaleInterpolation = _QuantLib.MarkovFunctionalSettings_KahaleInterpolation
    
    SmileDeleteArbitragePoints = _QuantLib.MarkovFunctionalSettings_SmileDeleteArbitragePoints
    
    SabrSmile = _QuantLib.MarkovFunctionalSettings_SabrSmile
    

    def __init__(self, *args):
        r"""
        ModelSettings() -> MarkovFunctionalSettings
        ModelSettings(Size yGridPoints, Real yStdDevs, Size gaussHermitePoints, Real digitalGap, Real marketRateAccuracy, Real lowerRateBound, Real upperRateBound, int adjustments, DoubleVector smileMoneyCheckpoints=std::vector< Real >()) -> MarkovFunctionalSettings
        """
        _QuantLib.MarkovFunctionalSettings_swiginit(self, _QuantLib.new_MarkovFunctionalSettings(*args))

    def validate(self):
        r"""validate(MarkovFunctionalSettings self)"""
        return _QuantLib.MarkovFunctionalSettings_validate(self)
    __swig_destroy__ = _QuantLib.delete_MarkovFunctionalSettings

# Register MarkovFunctionalSettings in _QuantLib:
_QuantLib.MarkovFunctionalSettings_swigregister(MarkovFunctionalSettings)
class Gaussian1dCapFloorEngine(PricingEngine):
    r"""Proxy of C++ Gaussian1dCapFloorEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(Gaussian1dCapFloorEngine self, ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >()) -> Gaussian1dCapFloorEngine"""
        _QuantLib.Gaussian1dCapFloorEngine_swiginit(self, _QuantLib.new_Gaussian1dCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dCapFloorEngine

# Register Gaussian1dCapFloorEngine in _QuantLib:
_QuantLib.Gaussian1dCapFloorEngine_swigregister(Gaussian1dCapFloorEngine)
class Gaussian1dSwaptionEngine(PricingEngine):
    r"""Proxy of C++ Gaussian1dSwaptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoProb = _QuantLib.Gaussian1dSwaptionEngine_NoProb
    
    Naive = _QuantLib.Gaussian1dSwaptionEngine_Naive
    
    Digital = _QuantLib.Gaussian1dSwaptionEngine_Digital
    

    def __init__(self, *args):
        r"""__init__(Gaussian1dSwaptionEngine self, ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), Gaussian1dSwaptionEngine::Probabilities const probabilities=NoProb) -> Gaussian1dSwaptionEngine"""
        _QuantLib.Gaussian1dSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dSwaptionEngine

# Register Gaussian1dSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dSwaptionEngine_swigregister(Gaussian1dSwaptionEngine)
class Gaussian1dJamshidianSwaptionEngine(PricingEngine):
    r"""Proxy of C++ Gaussian1dJamshidianSwaptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, model):
        r"""__init__(Gaussian1dJamshidianSwaptionEngine self, ext::shared_ptr< Gaussian1dModel > const & model) -> Gaussian1dJamshidianSwaptionEngine"""
        _QuantLib.Gaussian1dJamshidianSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dJamshidianSwaptionEngine(model))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dJamshidianSwaptionEngine

# Register Gaussian1dJamshidianSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dJamshidianSwaptionEngine_swigregister(Gaussian1dJamshidianSwaptionEngine)
class Gaussian1dNonstandardSwaptionEngine(PricingEngine):
    r"""Proxy of C++ Gaussian1dNonstandardSwaptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoProb = _QuantLib.Gaussian1dNonstandardSwaptionEngine_NoProb
    
    Naive = _QuantLib.Gaussian1dNonstandardSwaptionEngine_Naive
    
    Digital = _QuantLib.Gaussian1dNonstandardSwaptionEngine_Digital
    

    def __init__(self, *args):
        r"""__init__(Gaussian1dNonstandardSwaptionEngine self, ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, QuoteHandle oas=Handle< Quote >(), YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), Gaussian1dNonstandardSwaptionEngine::Probabilities const probabilities=NoProb) -> Gaussian1dNonstandardSwaptionEngine"""
        _QuantLib.Gaussian1dNonstandardSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dNonstandardSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dNonstandardSwaptionEngine

# Register Gaussian1dNonstandardSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dNonstandardSwaptionEngine_swigregister(Gaussian1dNonstandardSwaptionEngine)
class Gaussian1dFloatFloatSwaptionEngine(PricingEngine):
    r"""Proxy of C++ Gaussian1dFloatFloatSwaptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoProb = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_NoProb
    
    Naive = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_Naive
    
    Digital = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_Digital
    

    def __init__(self, *args):
        r"""__init__(Gaussian1dFloatFloatSwaptionEngine self, ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, QuoteHandle oas=Handle< Quote >(), YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), bool const includeTodaysExercise=False, Gaussian1dFloatFloatSwaptionEngine::Probabilities const probabilities=NoProb) -> Gaussian1dFloatFloatSwaptionEngine"""
        _QuantLib.Gaussian1dFloatFloatSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dFloatFloatSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dFloatFloatSwaptionEngine

# Register Gaussian1dFloatFloatSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dFloatFloatSwaptionEngine_swigregister(Gaussian1dFloatFloatSwaptionEngine)
class SegmentIntegral(object):
    r"""Proxy of C++ SegmentIntegral class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, intervals):
        r"""__init__(SegmentIntegral self, Size intervals) -> SegmentIntegral"""
        _QuantLib.SegmentIntegral_swiginit(self, _QuantLib.new_SegmentIntegral(intervals))

    def __call__(self, pyFunction, a, b):
        r"""__call__(SegmentIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.SegmentIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_SegmentIntegral

# Register SegmentIntegral in _QuantLib:
_QuantLib.SegmentIntegral_swigregister(SegmentIntegral)
class TrapezoidIntegralDefault(object):
    r"""Proxy of C++ TrapezoidIntegral< Default > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        r"""__init__(TrapezoidIntegralDefault self, Real accuracy, Size maxIterations) -> TrapezoidIntegralDefault"""
        _QuantLib.TrapezoidIntegralDefault_swiginit(self, _QuantLib.new_TrapezoidIntegralDefault(accuracy, maxIterations))

    def __call__(self, pyFunction, a, b):
        r"""__call__(TrapezoidIntegralDefault self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.TrapezoidIntegralDefault___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralDefault

# Register TrapezoidIntegralDefault in _QuantLib:
_QuantLib.TrapezoidIntegralDefault_swigregister(TrapezoidIntegralDefault)
class TrapezoidIntegralMidPoint(object):
    r"""Proxy of C++ TrapezoidIntegral< MidPoint > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        r"""__init__(TrapezoidIntegralMidPoint self, Real accuracy, Size maxIterations) -> TrapezoidIntegralMidPoint"""
        _QuantLib.TrapezoidIntegralMidPoint_swiginit(self, _QuantLib.new_TrapezoidIntegralMidPoint(accuracy, maxIterations))

    def __call__(self, pyFunction, a, b):
        r"""__call__(TrapezoidIntegralMidPoint self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.TrapezoidIntegralMidPoint___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralMidPoint

# Register TrapezoidIntegralMidPoint in _QuantLib:
_QuantLib.TrapezoidIntegralMidPoint_swigregister(TrapezoidIntegralMidPoint)
class SimpsonIntegral(object):
    r"""Proxy of C++ SimpsonIntegral class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        r"""__init__(SimpsonIntegral self, Real accuracy, Size maxIterations) -> SimpsonIntegral"""
        _QuantLib.SimpsonIntegral_swiginit(self, _QuantLib.new_SimpsonIntegral(accuracy, maxIterations))

    def __call__(self, pyFunction, a, b):
        r"""__call__(SimpsonIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.SimpsonIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_SimpsonIntegral

# Register SimpsonIntegral in _QuantLib:
_QuantLib.SimpsonIntegral_swigregister(SimpsonIntegral)
class GaussKronrodAdaptive(object):
    r"""Proxy of C++ GaussKronrodAdaptive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(GaussKronrodAdaptive self, Real tolerance, Size maxFunctionEvaluations=Null< Size >()) -> GaussKronrodAdaptive"""
        _QuantLib.GaussKronrodAdaptive_swiginit(self, _QuantLib.new_GaussKronrodAdaptive(*args))

    def __call__(self, pyFunction, a, b):
        r"""__call__(GaussKronrodAdaptive self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.GaussKronrodAdaptive___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodAdaptive

# Register GaussKronrodAdaptive in _QuantLib:
_QuantLib.GaussKronrodAdaptive_swigregister(GaussKronrodAdaptive)
class GaussKronrodNonAdaptive(object):
    r"""Proxy of C++ GaussKronrodNonAdaptive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, absoluteAccuracy, maxEvaluations, relativeAccuracy):
        r"""__init__(GaussKronrodNonAdaptive self, Real absoluteAccuracy, Size maxEvaluations, Real relativeAccuracy) -> GaussKronrodNonAdaptive"""
        _QuantLib.GaussKronrodNonAdaptive_swiginit(self, _QuantLib.new_GaussKronrodNonAdaptive(absoluteAccuracy, maxEvaluations, relativeAccuracy))

    def __call__(self, pyFunction, a, b):
        r"""__call__(GaussKronrodNonAdaptive self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.GaussKronrodNonAdaptive___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodNonAdaptive

# Register GaussKronrodNonAdaptive in _QuantLib:
_QuantLib.GaussKronrodNonAdaptive_swigregister(GaussKronrodNonAdaptive)
class GaussLobattoIntegral(object):
    r"""Proxy of C++ GaussLobattoIntegral class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(GaussLobattoIntegral self, Size maxIterations, Real absAccuracy, Real relAccuracy=Null< Real >(), bool useConvergenceEstimate=True) -> GaussLobattoIntegral"""
        _QuantLib.GaussLobattoIntegral_swiginit(self, _QuantLib.new_GaussLobattoIntegral(*args))

    def __call__(self, pyFunction, a, b):
        r"""__call__(GaussLobattoIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.GaussLobattoIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussLobattoIntegral

# Register GaussLobattoIntegral in _QuantLib:
_QuantLib.GaussLobattoIntegral_swigregister(GaussLobattoIntegral)
class GaussianQuadrature(object):
    r"""Proxy of C++ GaussianQuadrature class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def order(self):
        r"""order(GaussianQuadrature self) -> Size"""
        return _QuantLib.GaussianQuadrature_order(self)

    def weights(self):
        r"""weights(GaussianQuadrature self) -> Array"""
        return _QuantLib.GaussianQuadrature_weights(self)

    def x(self):
        r"""x(GaussianQuadrature self) -> Array"""
        return _QuantLib.GaussianQuadrature_x(self)

    def __call__(self, pyFunction):
        r"""__call__(GaussianQuadrature self, PyObject * pyFunction) -> Real"""
        return _QuantLib.GaussianQuadrature___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussianQuadrature

# Register GaussianQuadrature in _QuantLib:
_QuantLib.GaussianQuadrature_swigregister(GaussianQuadrature)
class GaussLaguerreIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussLaguerreIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, s=0.0):
        r"""__init__(GaussLaguerreIntegration self, Size n, Real s=0.0) -> GaussLaguerreIntegration"""
        _QuantLib.GaussLaguerreIntegration_swiginit(self, _QuantLib.new_GaussLaguerreIntegration(n, s))
    __swig_destroy__ = _QuantLib.delete_GaussLaguerreIntegration

# Register GaussLaguerreIntegration in _QuantLib:
_QuantLib.GaussLaguerreIntegration_swigregister(GaussLaguerreIntegration)
class GaussHermiteIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussHermiteIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, mu=0.0):
        r"""__init__(GaussHermiteIntegration self, Size n, Real mu=0.0) -> GaussHermiteIntegration"""
        _QuantLib.GaussHermiteIntegration_swiginit(self, _QuantLib.new_GaussHermiteIntegration(n, mu))
    __swig_destroy__ = _QuantLib.delete_GaussHermiteIntegration

# Register GaussHermiteIntegration in _QuantLib:
_QuantLib.GaussHermiteIntegration_swigregister(GaussHermiteIntegration)
class GaussJacobiIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussJacobiIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, alpha, beta):
        r"""__init__(GaussJacobiIntegration self, Size n, Real alpha, Real beta) -> GaussJacobiIntegration"""
        _QuantLib.GaussJacobiIntegration_swiginit(self, _QuantLib.new_GaussJacobiIntegration(n, alpha, beta))
    __swig_destroy__ = _QuantLib.delete_GaussJacobiIntegration

# Register GaussJacobiIntegration in _QuantLib:
_QuantLib.GaussJacobiIntegration_swigregister(GaussJacobiIntegration)
class GaussHyperbolicIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussHyperbolicIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(GaussHyperbolicIntegration self, Size n) -> GaussHyperbolicIntegration"""
        _QuantLib.GaussHyperbolicIntegration_swiginit(self, _QuantLib.new_GaussHyperbolicIntegration(n))
    __swig_destroy__ = _QuantLib.delete_GaussHyperbolicIntegration

# Register GaussHyperbolicIntegration in _QuantLib:
_QuantLib.GaussHyperbolicIntegration_swigregister(GaussHyperbolicIntegration)
class GaussLegendreIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussLegendreIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(GaussLegendreIntegration self, Size n) -> GaussLegendreIntegration"""
        _QuantLib.GaussLegendreIntegration_swiginit(self, _QuantLib.new_GaussLegendreIntegration(n))
    __swig_destroy__ = _QuantLib.delete_GaussLegendreIntegration

# Register GaussLegendreIntegration in _QuantLib:
_QuantLib.GaussLegendreIntegration_swigregister(GaussLegendreIntegration)
class GaussChebyshevIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussChebyshevIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(GaussChebyshevIntegration self, Size n) -> GaussChebyshevIntegration"""
        _QuantLib.GaussChebyshevIntegration_swiginit(self, _QuantLib.new_GaussChebyshevIntegration(n))
    __swig_destroy__ = _QuantLib.delete_GaussChebyshevIntegration

# Register GaussChebyshevIntegration in _QuantLib:
_QuantLib.GaussChebyshevIntegration_swigregister(GaussChebyshevIntegration)
class GaussChebyshev2ndIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussChebyshev2ndIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(GaussChebyshev2ndIntegration self, Size n) -> GaussChebyshev2ndIntegration"""
        _QuantLib.GaussChebyshev2ndIntegration_swiginit(self, _QuantLib.new_GaussChebyshev2ndIntegration(n))
    __swig_destroy__ = _QuantLib.delete_GaussChebyshev2ndIntegration

# Register GaussChebyshev2ndIntegration in _QuantLib:
_QuantLib.GaussChebyshev2ndIntegration_swigregister(GaussChebyshev2ndIntegration)
class GaussGegenbauerIntegration(GaussianQuadrature):
    r"""Proxy of C++ GaussGegenbauerIntegration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, lambda_parameter):
        r"""__init__(GaussGegenbauerIntegration self, Size n, Real lambda_parameter) -> GaussGegenbauerIntegration"""
        _QuantLib.GaussGegenbauerIntegration_swiginit(self, _QuantLib.new_GaussGegenbauerIntegration(n, lambda_parameter))
    __swig_destroy__ = _QuantLib.delete_GaussGegenbauerIntegration

# Register GaussGegenbauerIntegration in _QuantLib:
_QuantLib.GaussGegenbauerIntegration_swigregister(GaussGegenbauerIntegration)
class TanhSinhIntegral(object):
    r"""Proxy of C++ TanhSinhIntegral class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(TanhSinhIntegral self, Real relTolerance=std::sqrt(std::numeric_limits<Real>::epsilon()), Size maxRefinements=15, Real minComplement=std::numeric_limits< Real >::min()*4) -> TanhSinhIntegral"""
        _QuantLib.TanhSinhIntegral_swiginit(self, _QuantLib.new_TanhSinhIntegral(*args))

    def __call__(self, pyFunction, a, b):
        r"""__call__(TanhSinhIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"""
        return _QuantLib.TanhSinhIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TanhSinhIntegral

# Register TanhSinhIntegral in _QuantLib:
_QuantLib.TanhSinhIntegral_swigregister(TanhSinhIntegral)
class SampleNumber(object):
    r"""Proxy of C++ Sample< Real > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def value(self):
        r"""value(SampleNumber self) -> double const &"""
        return _QuantLib.SampleNumber_value(self)

    def weight(self):
        r"""weight(SampleNumber self) -> Real"""
        return _QuantLib.SampleNumber_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleNumber

# Register SampleNumber in _QuantLib:
_QuantLib.SampleNumber_swigregister(SampleNumber)
class SampleArray(object):
    r"""Proxy of C++ Sample< Array > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def value(self):
        r"""value(SampleArray self) -> Array"""
        return _QuantLib.SampleArray_value(self)

    def weight(self):
        r"""weight(SampleArray self) -> Real"""
        return _QuantLib.SampleArray_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleArray

# Register SampleArray in _QuantLib:
_QuantLib.SampleArray_swigregister(SampleArray)
class SampleRealVector(object):
    r"""Proxy of C++ Sample< std::vector< Real > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def value(self):
        r"""value(SampleRealVector self) -> DoubleVector"""
        return _QuantLib.SampleRealVector_value(self)

    def weight(self):
        r"""weight(SampleRealVector self) -> Real"""
        return _QuantLib.SampleRealVector_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleRealVector

# Register SampleRealVector in _QuantLib:
_QuantLib.SampleRealVector_swigregister(SampleRealVector)
class LecuyerUniformRng(object):
    r"""Proxy of C++ LecuyerUniformRng class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        r"""__init__(LecuyerUniformRng self, BigInteger seed=0) -> LecuyerUniformRng"""
        _QuantLib.LecuyerUniformRng_swiginit(self, _QuantLib.new_LecuyerUniformRng(seed))

    def next(self):
        r"""next(LecuyerUniformRng self) -> SampleNumber"""
        return _QuantLib.LecuyerUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRng

# Register LecuyerUniformRng in _QuantLib:
_QuantLib.LecuyerUniformRng_swigregister(LecuyerUniformRng)
class KnuthUniformRng(object):
    r"""Proxy of C++ KnuthUniformRng class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        r"""__init__(KnuthUniformRng self, BigInteger seed=0) -> KnuthUniformRng"""
        _QuantLib.KnuthUniformRng_swiginit(self, _QuantLib.new_KnuthUniformRng(seed))

    def next(self):
        r"""next(KnuthUniformRng self) -> SampleNumber"""
        return _QuantLib.KnuthUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRng

# Register KnuthUniformRng in _QuantLib:
_QuantLib.KnuthUniformRng_swigregister(KnuthUniformRng)
class MersenneTwisterUniformRng(object):
    r"""Proxy of C++ MersenneTwisterUniformRng class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        r"""__init__(MersenneTwisterUniformRng self, BigInteger seed=0) -> MersenneTwisterUniformRng"""
        _QuantLib.MersenneTwisterUniformRng_swiginit(self, _QuantLib.new_MersenneTwisterUniformRng(seed))

    def next(self):
        r"""next(MersenneTwisterUniformRng self) -> SampleNumber"""
        return _QuantLib.MersenneTwisterUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRng

# Register MersenneTwisterUniformRng in _QuantLib:
_QuantLib.MersenneTwisterUniformRng_swigregister(MersenneTwisterUniformRng)
class UniformRandomGenerator(object):
    r"""Proxy of C++ UniformRandomGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        r"""__init__(UniformRandomGenerator self, BigInteger seed=0) -> UniformRandomGenerator"""
        _QuantLib.UniformRandomGenerator_swiginit(self, _QuantLib.new_UniformRandomGenerator(seed))

    def next(self):
        r"""next(UniformRandomGenerator self) -> SampleNumber"""
        return _QuantLib.UniformRandomGenerator_next(self)

    def nextValue(self):
        r"""nextValue(UniformRandomGenerator self) -> Real"""
        return _QuantLib.UniformRandomGenerator_nextValue(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomGenerator

# Register UniformRandomGenerator in _QuantLib:
_QuantLib.UniformRandomGenerator_swigregister(UniformRandomGenerator)
class CentralLimitLecuyerGaussianRng(object):
    r"""Proxy of C++ CLGaussianRng< LecuyerUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(CentralLimitLecuyerGaussianRng self, LecuyerUniformRng rng) -> CentralLimitLecuyerGaussianRng"""
        _QuantLib.CentralLimitLecuyerGaussianRng_swiginit(self, _QuantLib.new_CentralLimitLecuyerGaussianRng(rng))

    def next(self):
        r"""next(CentralLimitLecuyerGaussianRng self) -> SampleNumber"""
        return _QuantLib.CentralLimitLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitLecuyerGaussianRng

# Register CentralLimitLecuyerGaussianRng in _QuantLib:
_QuantLib.CentralLimitLecuyerGaussianRng_swigregister(CentralLimitLecuyerGaussianRng)
class CentralLimitKnuthGaussianRng(object):
    r"""Proxy of C++ CLGaussianRng< KnuthUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(CentralLimitKnuthGaussianRng self, KnuthUniformRng rng) -> CentralLimitKnuthGaussianRng"""
        _QuantLib.CentralLimitKnuthGaussianRng_swiginit(self, _QuantLib.new_CentralLimitKnuthGaussianRng(rng))

    def next(self):
        r"""next(CentralLimitKnuthGaussianRng self) -> SampleNumber"""
        return _QuantLib.CentralLimitKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitKnuthGaussianRng

# Register CentralLimitKnuthGaussianRng in _QuantLib:
_QuantLib.CentralLimitKnuthGaussianRng_swigregister(CentralLimitKnuthGaussianRng)
class CentralLimitMersenneTwisterGaussianRng(object):
    r"""Proxy of C++ CLGaussianRng< MersenneTwisterUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(CentralLimitMersenneTwisterGaussianRng self, MersenneTwisterUniformRng rng) -> CentralLimitMersenneTwisterGaussianRng"""
        _QuantLib.CentralLimitMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_CentralLimitMersenneTwisterGaussianRng(rng))

    def next(self):
        r"""next(CentralLimitMersenneTwisterGaussianRng self) -> SampleNumber"""
        return _QuantLib.CentralLimitMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitMersenneTwisterGaussianRng

# Register CentralLimitMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.CentralLimitMersenneTwisterGaussianRng_swigregister(CentralLimitMersenneTwisterGaussianRng)
class BoxMullerLecuyerGaussianRng(object):
    r"""Proxy of C++ BoxMullerGaussianRng< LecuyerUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(BoxMullerLecuyerGaussianRng self, LecuyerUniformRng rng) -> BoxMullerLecuyerGaussianRng"""
        _QuantLib.BoxMullerLecuyerGaussianRng_swiginit(self, _QuantLib.new_BoxMullerLecuyerGaussianRng(rng))

    def next(self):
        r"""next(BoxMullerLecuyerGaussianRng self) -> SampleNumber"""
        return _QuantLib.BoxMullerLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerLecuyerGaussianRng

# Register BoxMullerLecuyerGaussianRng in _QuantLib:
_QuantLib.BoxMullerLecuyerGaussianRng_swigregister(BoxMullerLecuyerGaussianRng)
class BoxMullerKnuthGaussianRng(object):
    r"""Proxy of C++ BoxMullerGaussianRng< KnuthUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(BoxMullerKnuthGaussianRng self, KnuthUniformRng rng) -> BoxMullerKnuthGaussianRng"""
        _QuantLib.BoxMullerKnuthGaussianRng_swiginit(self, _QuantLib.new_BoxMullerKnuthGaussianRng(rng))

    def next(self):
        r"""next(BoxMullerKnuthGaussianRng self) -> SampleNumber"""
        return _QuantLib.BoxMullerKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerKnuthGaussianRng

# Register BoxMullerKnuthGaussianRng in _QuantLib:
_QuantLib.BoxMullerKnuthGaussianRng_swigregister(BoxMullerKnuthGaussianRng)
class BoxMullerMersenneTwisterGaussianRng(object):
    r"""Proxy of C++ BoxMullerGaussianRng< MersenneTwisterUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(BoxMullerMersenneTwisterGaussianRng self, MersenneTwisterUniformRng rng) -> BoxMullerMersenneTwisterGaussianRng"""
        _QuantLib.BoxMullerMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_BoxMullerMersenneTwisterGaussianRng(rng))

    def next(self):
        r"""next(BoxMullerMersenneTwisterGaussianRng self) -> SampleNumber"""
        return _QuantLib.BoxMullerMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerMersenneTwisterGaussianRng

# Register BoxMullerMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.BoxMullerMersenneTwisterGaussianRng_swigregister(BoxMullerMersenneTwisterGaussianRng)
class MoroInvCumulativeLecuyerGaussianRng(object):
    r"""Proxy of C++ InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(MoroInvCumulativeLecuyerGaussianRng self, LecuyerUniformRng rng) -> MoroInvCumulativeLecuyerGaussianRng"""
        _QuantLib.MoroInvCumulativeLecuyerGaussianRng_swiginit(self, _QuantLib.new_MoroInvCumulativeLecuyerGaussianRng(rng))

    def next(self):
        r"""next(MoroInvCumulativeLecuyerGaussianRng self) -> SampleNumber"""
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRng

# Register MoroInvCumulativeLecuyerGaussianRng in _QuantLib:
_QuantLib.MoroInvCumulativeLecuyerGaussianRng_swigregister(MoroInvCumulativeLecuyerGaussianRng)
class MoroInvCumulativeKnuthGaussianRng(object):
    r"""Proxy of C++ InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(MoroInvCumulativeKnuthGaussianRng self, KnuthUniformRng rng) -> MoroInvCumulativeKnuthGaussianRng"""
        _QuantLib.MoroInvCumulativeKnuthGaussianRng_swiginit(self, _QuantLib.new_MoroInvCumulativeKnuthGaussianRng(rng))

    def next(self):
        r"""next(MoroInvCumulativeKnuthGaussianRng self) -> SampleNumber"""
        return _QuantLib.MoroInvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRng

# Register MoroInvCumulativeKnuthGaussianRng in _QuantLib:
_QuantLib.MoroInvCumulativeKnuthGaussianRng_swigregister(MoroInvCumulativeKnuthGaussianRng)
class MoroInvCumulativeMersenneTwisterGaussianRng(object):
    r"""Proxy of C++ InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(MoroInvCumulativeMersenneTwisterGaussianRng self, MersenneTwisterUniformRng rng) -> MoroInvCumulativeMersenneTwisterGaussianRng"""
        _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRng(rng))

    def next(self):
        r"""next(MoroInvCumulativeMersenneTwisterGaussianRng self) -> SampleNumber"""
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRng

# Register MoroInvCumulativeMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_swigregister(MoroInvCumulativeMersenneTwisterGaussianRng)
class InvCumulativeLecuyerGaussianRng(object):
    r"""Proxy of C++ InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(InvCumulativeLecuyerGaussianRng self, LecuyerUniformRng rng) -> InvCumulativeLecuyerGaussianRng"""
        _QuantLib.InvCumulativeLecuyerGaussianRng_swiginit(self, _QuantLib.new_InvCumulativeLecuyerGaussianRng(rng))

    def next(self):
        r"""next(InvCumulativeLecuyerGaussianRng self) -> SampleNumber"""
        return _QuantLib.InvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRng

# Register InvCumulativeLecuyerGaussianRng in _QuantLib:
_QuantLib.InvCumulativeLecuyerGaussianRng_swigregister(InvCumulativeLecuyerGaussianRng)
class InvCumulativeKnuthGaussianRng(object):
    r"""Proxy of C++ InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(InvCumulativeKnuthGaussianRng self, KnuthUniformRng rng) -> InvCumulativeKnuthGaussianRng"""
        _QuantLib.InvCumulativeKnuthGaussianRng_swiginit(self, _QuantLib.new_InvCumulativeKnuthGaussianRng(rng))

    def next(self):
        r"""next(InvCumulativeKnuthGaussianRng self) -> SampleNumber"""
        return _QuantLib.InvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRng

# Register InvCumulativeKnuthGaussianRng in _QuantLib:
_QuantLib.InvCumulativeKnuthGaussianRng_swigregister(InvCumulativeKnuthGaussianRng)
class InvCumulativeMersenneTwisterGaussianRng(object):
    r"""Proxy of C++ InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(InvCumulativeMersenneTwisterGaussianRng self, MersenneTwisterUniformRng rng) -> InvCumulativeMersenneTwisterGaussianRng"""
        _QuantLib.InvCumulativeMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_InvCumulativeMersenneTwisterGaussianRng(rng))

    def next(self):
        r"""next(InvCumulativeMersenneTwisterGaussianRng self) -> SampleNumber"""
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRng

# Register InvCumulativeMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.InvCumulativeMersenneTwisterGaussianRng_swigregister(InvCumulativeMersenneTwisterGaussianRng)
class GaussianRandomGenerator(object):
    r"""Proxy of C++ GaussianRandomGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        r"""__init__(GaussianRandomGenerator self, UniformRandomGenerator rng) -> GaussianRandomGenerator"""
        _QuantLib.GaussianRandomGenerator_swiginit(self, _QuantLib.new_GaussianRandomGenerator(rng))

    def next(self):
        r"""next(GaussianRandomGenerator self) -> SampleNumber"""
        return _QuantLib.GaussianRandomGenerator_next(self)

    def nextValue(self):
        r"""nextValue(GaussianRandomGenerator self) -> Real"""
        return _QuantLib.GaussianRandomGenerator_nextValue(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomGenerator

# Register GaussianRandomGenerator in _QuantLib:
_QuantLib.GaussianRandomGenerator_swigregister(GaussianRandomGenerator)
class HaltonRsg(object):
    r"""Proxy of C++ HaltonRsg class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimensionality, seed=0, randomStart=True, randomShift=False):
        r"""__init__(HaltonRsg self, Size dimensionality, unsigned long seed=0, bool randomStart=True, bool randomShift=False) -> HaltonRsg"""
        _QuantLib.HaltonRsg_swiginit(self, _QuantLib.new_HaltonRsg(dimensionality, seed, randomStart, randomShift))

    def nextSequence(self):
        r"""nextSequence(HaltonRsg self) -> SampleRealVector"""
        return _QuantLib.HaltonRsg_nextSequence(self)

    def lastSequence(self):
        r"""lastSequence(HaltonRsg self) -> SampleRealVector"""
        return _QuantLib.HaltonRsg_lastSequence(self)

    def dimension(self):
        r"""dimension(HaltonRsg self) -> Size"""
        return _QuantLib.HaltonRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_HaltonRsg

# Register HaltonRsg in _QuantLib:
_QuantLib.HaltonRsg_swigregister(HaltonRsg)
class SobolRsg(object):
    r"""Proxy of C++ SobolRsg class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Unit = _QuantLib.SobolRsg_Unit
    
    Jaeckel = _QuantLib.SobolRsg_Jaeckel
    
    SobolLevitan = _QuantLib.SobolRsg_SobolLevitan
    
    SobolLevitanLemieux = _QuantLib.SobolRsg_SobolLevitanLemieux
    
    JoeKuoD5 = _QuantLib.SobolRsg_JoeKuoD5
    
    JoeKuoD6 = _QuantLib.SobolRsg_JoeKuoD6
    
    JoeKuoD7 = _QuantLib.SobolRsg_JoeKuoD7
    
    Kuo = _QuantLib.SobolRsg_Kuo
    
    Kuo2 = _QuantLib.SobolRsg_Kuo2
    
    Kuo3 = _QuantLib.SobolRsg_Kuo3
    

    def __init__(self, *args):
        r"""__init__(SobolRsg self, Size dimensionality, BigInteger seed=0, SobolRsg::DirectionIntegers directionIntegers=QuantLib::SobolRsg::Jaeckel) -> SobolRsg"""
        _QuantLib.SobolRsg_swiginit(self, _QuantLib.new_SobolRsg(*args))

    def nextSequence(self):
        r"""nextSequence(SobolRsg self) -> SampleRealVector"""
        return _QuantLib.SobolRsg_nextSequence(self)

    def lastSequence(self):
        r"""lastSequence(SobolRsg self) -> SampleRealVector"""
        return _QuantLib.SobolRsg_lastSequence(self)

    def dimension(self):
        r"""dimension(SobolRsg self) -> Size"""
        return _QuantLib.SobolRsg_dimension(self)

    def skipTo(self, n):
        r"""skipTo(SobolRsg self, Size n)"""
        return _QuantLib.SobolRsg_skipTo(self, n)

    def nextInt32Sequence(self):
        r"""nextInt32Sequence(SobolRsg self) -> UnsignedIntVector"""
        return _QuantLib.SobolRsg_nextInt32Sequence(self)
    __swig_destroy__ = _QuantLib.delete_SobolRsg

# Register SobolRsg in _QuantLib:
_QuantLib.SobolRsg_swigregister(SobolRsg)
class SobolBrownianBridgeRsg(object):
    r"""Proxy of C++ SobolBrownianBridgeRsg class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, factors, steps):
        r"""__init__(SobolBrownianBridgeRsg self, Size factors, Size steps) -> SobolBrownianBridgeRsg"""
        _QuantLib.SobolBrownianBridgeRsg_swiginit(self, _QuantLib.new_SobolBrownianBridgeRsg(factors, steps))

    def nextSequence(self):
        r"""nextSequence(SobolBrownianBridgeRsg self) -> SampleRealVector"""
        return _QuantLib.SobolBrownianBridgeRsg_nextSequence(self)

    def lastSequence(self):
        r"""lastSequence(SobolBrownianBridgeRsg self) -> SampleRealVector"""
        return _QuantLib.SobolBrownianBridgeRsg_lastSequence(self)

    def dimension(self):
        r"""dimension(SobolBrownianBridgeRsg self) -> Size"""
        return _QuantLib.SobolBrownianBridgeRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_SobolBrownianBridgeRsg

# Register SobolBrownianBridgeRsg in _QuantLib:
_QuantLib.SobolBrownianBridgeRsg_swigregister(SobolBrownianBridgeRsg)
class LecuyerUniformRsg(object):
    r"""Proxy of C++ RandomSequenceGenerator< LecuyerUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(LecuyerUniformRsg self, Size dimensionality, LecuyerUniformRng rng) -> LecuyerUniformRsg
        __init__(LecuyerUniformRsg self, Size dimensionality, BigNatural seed=0) -> LecuyerUniformRsg
        """
        _QuantLib.LecuyerUniformRsg_swiginit(self, _QuantLib.new_LecuyerUniformRsg(*args))

    def nextSequence(self):
        r"""nextSequence(LecuyerUniformRsg self) -> SampleRealVector"""
        return _QuantLib.LecuyerUniformRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(LecuyerUniformRsg self) -> Size"""
        return _QuantLib.LecuyerUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRsg

# Register LecuyerUniformRsg in _QuantLib:
_QuantLib.LecuyerUniformRsg_swigregister(LecuyerUniformRsg)
class KnuthUniformRsg(object):
    r"""Proxy of C++ RandomSequenceGenerator< KnuthUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(KnuthUniformRsg self, Size dimensionality, KnuthUniformRng rng) -> KnuthUniformRsg
        __init__(KnuthUniformRsg self, Size dimensionality, BigNatural seed=0) -> KnuthUniformRsg
        """
        _QuantLib.KnuthUniformRsg_swiginit(self, _QuantLib.new_KnuthUniformRsg(*args))

    def nextSequence(self):
        r"""nextSequence(KnuthUniformRsg self) -> SampleRealVector"""
        return _QuantLib.KnuthUniformRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(KnuthUniformRsg self) -> Size"""
        return _QuantLib.KnuthUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRsg

# Register KnuthUniformRsg in _QuantLib:
_QuantLib.KnuthUniformRsg_swigregister(KnuthUniformRsg)
class MersenneTwisterUniformRsg(object):
    r"""Proxy of C++ RandomSequenceGenerator< MersenneTwisterUniformRng > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MersenneTwisterUniformRsg self, Size dimensionality, MersenneTwisterUniformRng rng) -> MersenneTwisterUniformRsg
        __init__(MersenneTwisterUniformRsg self, Size dimensionality, BigNatural seed=0) -> MersenneTwisterUniformRsg
        """
        _QuantLib.MersenneTwisterUniformRsg_swiginit(self, _QuantLib.new_MersenneTwisterUniformRsg(*args))

    def nextSequence(self):
        r"""nextSequence(MersenneTwisterUniformRsg self) -> SampleRealVector"""
        return _QuantLib.MersenneTwisterUniformRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(MersenneTwisterUniformRsg self) -> Size"""
        return _QuantLib.MersenneTwisterUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRsg

# Register MersenneTwisterUniformRsg in _QuantLib:
_QuantLib.MersenneTwisterUniformRsg_swigregister(MersenneTwisterUniformRsg)
class UniformRandomSequenceGenerator(object):
    r"""Proxy of C++ UniformRandomSequenceGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimensionality, rng):
        r"""__init__(UniformRandomSequenceGenerator self, Size dimensionality, UniformRandomGenerator rng) -> UniformRandomSequenceGenerator"""
        _QuantLib.UniformRandomSequenceGenerator_swiginit(self, _QuantLib.new_UniformRandomSequenceGenerator(dimensionality, rng))

    def nextSequence(self):
        r"""nextSequence(UniformRandomSequenceGenerator self) -> SampleRealVector"""
        return _QuantLib.UniformRandomSequenceGenerator_nextSequence(self)

    def dimension(self):
        r"""dimension(UniformRandomSequenceGenerator self) -> Size"""
        return _QuantLib.UniformRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomSequenceGenerator

# Register UniformRandomSequenceGenerator in _QuantLib:
_QuantLib.UniformRandomSequenceGenerator_swigregister(UniformRandomSequenceGenerator)
class UniformLowDiscrepancySequenceGenerator(object):
    r"""Proxy of C++ UniformLowDiscrepancySequenceGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(UniformLowDiscrepancySequenceGenerator self, Size dimensionality, BigInteger seed=0, SobolRsg::DirectionIntegers directionIntegers=QuantLib::SobolRsg::Jaeckel) -> UniformLowDiscrepancySequenceGenerator"""
        _QuantLib.UniformLowDiscrepancySequenceGenerator_swiginit(self, _QuantLib.new_UniformLowDiscrepancySequenceGenerator(*args))

    def nextSequence(self):
        r"""nextSequence(UniformLowDiscrepancySequenceGenerator self) -> SampleRealVector"""
        return _QuantLib.UniformLowDiscrepancySequenceGenerator_nextSequence(self)

    def dimension(self):
        r"""dimension(UniformLowDiscrepancySequenceGenerator self) -> Size"""
        return _QuantLib.UniformLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformLowDiscrepancySequenceGenerator

# Register UniformLowDiscrepancySequenceGenerator in _QuantLib:
_QuantLib.UniformLowDiscrepancySequenceGenerator_swigregister(UniformLowDiscrepancySequenceGenerator)
class MoroInvCumulativeLecuyerGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MoroInvCumulativeLecuyerGaussianRsg self, LecuyerUniformRsg uniformSequenceGenerator) -> MoroInvCumulativeLecuyerGaussianRsg
        __init__(MoroInvCumulativeLecuyerGaussianRsg self, LecuyerUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeLecuyerGaussianRsg
        """
        _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeLecuyerGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(MoroInvCumulativeLecuyerGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(MoroInvCumulativeLecuyerGaussianRsg self) -> Size"""
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRsg

# Register MoroInvCumulativeLecuyerGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeLecuyerGaussianRsg_swigregister(MoroInvCumulativeLecuyerGaussianRsg)
class MoroInvCumulativeKnuthGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MoroInvCumulativeKnuthGaussianRsg self, KnuthUniformRsg uniformSequenceGenerator) -> MoroInvCumulativeKnuthGaussianRsg
        __init__(MoroInvCumulativeKnuthGaussianRsg self, KnuthUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeKnuthGaussianRsg
        """
        _QuantLib.MoroInvCumulativeKnuthGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeKnuthGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(MoroInvCumulativeKnuthGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(MoroInvCumulativeKnuthGaussianRsg self) -> Size"""
        return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRsg

# Register MoroInvCumulativeKnuthGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeKnuthGaussianRsg_swigregister(MoroInvCumulativeKnuthGaussianRsg)
class MoroInvCumulativeMersenneTwisterGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MoroInvCumulativeMersenneTwisterGaussianRsg self, MersenneTwisterUniformRsg uniformSequenceGenerator) -> MoroInvCumulativeMersenneTwisterGaussianRsg
        __init__(MoroInvCumulativeMersenneTwisterGaussianRsg self, MersenneTwisterUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeMersenneTwisterGaussianRsg
        """
        _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(MoroInvCumulativeMersenneTwisterGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(MoroInvCumulativeMersenneTwisterGaussianRsg self) -> Size"""
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRsg

# Register MoroInvCumulativeMersenneTwisterGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister(MoroInvCumulativeMersenneTwisterGaussianRsg)
class MoroInvCumulativeHaltonGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MoroInvCumulativeHaltonGaussianRsg self, HaltonRsg uniformSequenceGenerator) -> MoroInvCumulativeHaltonGaussianRsg
        __init__(MoroInvCumulativeHaltonGaussianRsg self, HaltonRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeHaltonGaussianRsg
        """
        _QuantLib.MoroInvCumulativeHaltonGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeHaltonGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(MoroInvCumulativeHaltonGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(MoroInvCumulativeHaltonGaussianRsg self) -> Size"""
        return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeHaltonGaussianRsg

# Register MoroInvCumulativeHaltonGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeHaltonGaussianRsg_swigregister(MoroInvCumulativeHaltonGaussianRsg)
class MoroInvCumulativeSobolGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(MoroInvCumulativeSobolGaussianRsg self, SobolRsg uniformSequenceGenerator) -> MoroInvCumulativeSobolGaussianRsg
        __init__(MoroInvCumulativeSobolGaussianRsg self, SobolRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeSobolGaussianRsg
        """
        _QuantLib.MoroInvCumulativeSobolGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeSobolGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(MoroInvCumulativeSobolGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.MoroInvCumulativeSobolGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(MoroInvCumulativeSobolGaussianRsg self) -> Size"""
        return _QuantLib.MoroInvCumulativeSobolGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeSobolGaussianRsg

# Register MoroInvCumulativeSobolGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeSobolGaussianRsg_swigregister(MoroInvCumulativeSobolGaussianRsg)
class InvCumulativeLecuyerGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(InvCumulativeLecuyerGaussianRsg self, LecuyerUniformRsg uniformSequenceGenerator) -> InvCumulativeLecuyerGaussianRsg
        __init__(InvCumulativeLecuyerGaussianRsg self, LecuyerUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeLecuyerGaussianRsg
        """
        _QuantLib.InvCumulativeLecuyerGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeLecuyerGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(InvCumulativeLecuyerGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.InvCumulativeLecuyerGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(InvCumulativeLecuyerGaussianRsg self) -> Size"""
        return _QuantLib.InvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRsg

# Register InvCumulativeLecuyerGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeLecuyerGaussianRsg_swigregister(InvCumulativeLecuyerGaussianRsg)
class InvCumulativeKnuthGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(InvCumulativeKnuthGaussianRsg self, KnuthUniformRsg uniformSequenceGenerator) -> InvCumulativeKnuthGaussianRsg
        __init__(InvCumulativeKnuthGaussianRsg self, KnuthUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeKnuthGaussianRsg
        """
        _QuantLib.InvCumulativeKnuthGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeKnuthGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(InvCumulativeKnuthGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.InvCumulativeKnuthGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(InvCumulativeKnuthGaussianRsg self) -> Size"""
        return _QuantLib.InvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRsg

# Register InvCumulativeKnuthGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeKnuthGaussianRsg_swigregister(InvCumulativeKnuthGaussianRsg)
class InvCumulativeMersenneTwisterGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(InvCumulativeMersenneTwisterGaussianRsg self, MersenneTwisterUniformRsg uniformSequenceGenerator) -> InvCumulativeMersenneTwisterGaussianRsg
        __init__(InvCumulativeMersenneTwisterGaussianRsg self, MersenneTwisterUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeMersenneTwisterGaussianRsg
        """
        _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeMersenneTwisterGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(InvCumulativeMersenneTwisterGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(InvCumulativeMersenneTwisterGaussianRsg self) -> Size"""
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRsg

# Register InvCumulativeMersenneTwisterGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeMersenneTwisterGaussianRsg_swigregister(InvCumulativeMersenneTwisterGaussianRsg)
class InvCumulativeHaltonGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(InvCumulativeHaltonGaussianRsg self, HaltonRsg uniformSequenceGenerator) -> InvCumulativeHaltonGaussianRsg
        __init__(InvCumulativeHaltonGaussianRsg self, HaltonRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeHaltonGaussianRsg
        """
        _QuantLib.InvCumulativeHaltonGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeHaltonGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(InvCumulativeHaltonGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.InvCumulativeHaltonGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(InvCumulativeHaltonGaussianRsg self) -> Size"""
        return _QuantLib.InvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeHaltonGaussianRsg

# Register InvCumulativeHaltonGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeHaltonGaussianRsg_swigregister(InvCumulativeHaltonGaussianRsg)
class InvCumulativeSobolGaussianRsg(object):
    r"""Proxy of C++ InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(InvCumulativeSobolGaussianRsg self, SobolRsg uniformSequenceGenerator) -> InvCumulativeSobolGaussianRsg
        __init__(InvCumulativeSobolGaussianRsg self, SobolRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeSobolGaussianRsg
        """
        _QuantLib.InvCumulativeSobolGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeSobolGaussianRsg(*args))

    def nextSequence(self):
        r"""nextSequence(InvCumulativeSobolGaussianRsg self) -> SampleRealVector"""
        return _QuantLib.InvCumulativeSobolGaussianRsg_nextSequence(self)

    def dimension(self):
        r"""dimension(InvCumulativeSobolGaussianRsg self) -> Size"""
        return _QuantLib.InvCumulativeSobolGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeSobolGaussianRsg

# Register InvCumulativeSobolGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeSobolGaussianRsg_swigregister(InvCumulativeSobolGaussianRsg)
class GaussianRandomSequenceGenerator(object):
    r"""Proxy of C++ GaussianRandomSequenceGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        r"""__init__(GaussianRandomSequenceGenerator self, UniformRandomSequenceGenerator uniformSequenceGenerator) -> GaussianRandomSequenceGenerator"""
        _QuantLib.GaussianRandomSequenceGenerator_swiginit(self, _QuantLib.new_GaussianRandomSequenceGenerator(uniformSequenceGenerator))

    def nextSequence(self):
        r"""nextSequence(GaussianRandomSequenceGenerator self) -> SampleRealVector"""
        return _QuantLib.GaussianRandomSequenceGenerator_nextSequence(self)

    def dimension(self):
        r"""dimension(GaussianRandomSequenceGenerator self) -> Size"""
        return _QuantLib.GaussianRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomSequenceGenerator

# Register GaussianRandomSequenceGenerator in _QuantLib:
_QuantLib.GaussianRandomSequenceGenerator_swigregister(GaussianRandomSequenceGenerator)
class GaussianLowDiscrepancySequenceGenerator(object):
    r"""Proxy of C++ GaussianLowDiscrepancySequenceGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, u):
        r"""__init__(GaussianLowDiscrepancySequenceGenerator self, UniformLowDiscrepancySequenceGenerator u) -> GaussianLowDiscrepancySequenceGenerator"""
        _QuantLib.GaussianLowDiscrepancySequenceGenerator_swiginit(self, _QuantLib.new_GaussianLowDiscrepancySequenceGenerator(u))

    def nextSequence(self):
        r"""nextSequence(GaussianLowDiscrepancySequenceGenerator self) -> SampleRealVector"""
        return _QuantLib.GaussianLowDiscrepancySequenceGenerator_nextSequence(self)

    def dimension(self):
        r"""dimension(GaussianLowDiscrepancySequenceGenerator self) -> Size"""
        return _QuantLib.GaussianLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianLowDiscrepancySequenceGenerator

# Register GaussianLowDiscrepancySequenceGenerator in _QuantLib:
_QuantLib.GaussianLowDiscrepancySequenceGenerator_swigregister(GaussianLowDiscrepancySequenceGenerator)
class BrownianGenerator(object):
    r"""Proxy of C++ BrownianGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def nextStep(self, arg2):
        r"""nextStep(BrownianGenerator self, DoubleVector arg2) -> Real"""
        return _QuantLib.BrownianGenerator_nextStep(self, arg2)

    def nextPath(self):
        r"""nextPath(BrownianGenerator self) -> Real"""
        return _QuantLib.BrownianGenerator_nextPath(self)

    def numberOfFactors(self):
        r"""numberOfFactors(BrownianGenerator self) -> Size"""
        return _QuantLib.BrownianGenerator_numberOfFactors(self)

    def numberOfSteps(self):
        r"""numberOfSteps(BrownianGenerator self) -> Size"""
        return _QuantLib.BrownianGenerator_numberOfSteps(self)
    __swig_destroy__ = _QuantLib.delete_BrownianGenerator

# Register BrownianGenerator in _QuantLib:
_QuantLib.BrownianGenerator_swigregister(BrownianGenerator)
class BrownianGeneratorFactory(object):
    r"""Proxy of C++ BrownianGeneratorFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(self, factors, steps):
        r"""create(BrownianGeneratorFactory self, Size factors, Size steps) -> ext::shared_ptr< BrownianGenerator >"""
        return _QuantLib.BrownianGeneratorFactory_create(self, factors, steps)
    __swig_destroy__ = _QuantLib.delete_BrownianGeneratorFactory

# Register BrownianGeneratorFactory in _QuantLib:
_QuantLib.BrownianGeneratorFactory_swigregister(BrownianGeneratorFactory)
class MTBrownianGenerator(BrownianGenerator):
    r"""Proxy of C++ MTBrownianGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, factors, steps, seed=0):
        r"""__init__(MTBrownianGenerator self, Size factors, Size steps, unsigned long seed=0) -> MTBrownianGenerator"""
        _QuantLib.MTBrownianGenerator_swiginit(self, _QuantLib.new_MTBrownianGenerator(factors, steps, seed))
    __swig_destroy__ = _QuantLib.delete_MTBrownianGenerator

# Register MTBrownianGenerator in _QuantLib:
_QuantLib.MTBrownianGenerator_swigregister(MTBrownianGenerator)
class MTBrownianGeneratorFactory(BrownianGeneratorFactory):
    r"""Proxy of C++ MTBrownianGeneratorFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        r"""__init__(MTBrownianGeneratorFactory self, unsigned long seed=0) -> MTBrownianGeneratorFactory"""
        _QuantLib.MTBrownianGeneratorFactory_swiginit(self, _QuantLib.new_MTBrownianGeneratorFactory(seed))
    __swig_destroy__ = _QuantLib.delete_MTBrownianGeneratorFactory

# Register MTBrownianGeneratorFactory in _QuantLib:
_QuantLib.MTBrownianGeneratorFactory_swigregister(MTBrownianGeneratorFactory)
class SobolBrownianGenerator(BrownianGenerator):
    r"""Proxy of C++ SobolBrownianGenerator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Factors = _QuantLib.SobolBrownianGenerator_Factors
    
    Steps = _QuantLib.SobolBrownianGenerator_Steps
    
    Diagonal = _QuantLib.SobolBrownianGenerator_Diagonal
    

    def __init__(self, *args):
        r"""__init__(SobolBrownianGenerator self, Size factors, Size steps, SobolBrownianGenerator::Ordering ordering, unsigned long seed=0, SobolRsg::DirectionIntegers directionIntegers=Jaeckel) -> SobolBrownianGenerator"""
        _QuantLib.SobolBrownianGenerator_swiginit(self, _QuantLib.new_SobolBrownianGenerator(*args))
    __swig_destroy__ = _QuantLib.delete_SobolBrownianGenerator

# Register SobolBrownianGenerator in _QuantLib:
_QuantLib.SobolBrownianGenerator_swigregister(SobolBrownianGenerator)
class SobolBrownianGeneratorFactory(BrownianGeneratorFactory):
    r"""Proxy of C++ SobolBrownianGeneratorFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(SobolBrownianGeneratorFactory self, SobolBrownianGenerator::Ordering ordering, unsigned long seed=0, SobolRsg::DirectionIntegers directionIntegers=Jaeckel) -> SobolBrownianGeneratorFactory"""
        _QuantLib.SobolBrownianGeneratorFactory_swiginit(self, _QuantLib.new_SobolBrownianGeneratorFactory(*args))
    __swig_destroy__ = _QuantLib.delete_SobolBrownianGeneratorFactory

# Register SobolBrownianGeneratorFactory in _QuantLib:
_QuantLib.SobolBrownianGeneratorFactory_swigregister(SobolBrownianGeneratorFactory)
class EvolutionDescription(object):
    r"""Proxy of C++ EvolutionDescription class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(EvolutionDescription self, DoubleVector rateTimes, DoubleVector evolutionTimes={}, UnsignedIntPairVector relevanceRates={}) -> EvolutionDescription"""
        _QuantLib.EvolutionDescription_swiginit(self, _QuantLib.new_EvolutionDescription(*args))

    def rateTimes(self):
        r"""rateTimes(EvolutionDescription self) -> DoubleVector"""
        return _QuantLib.EvolutionDescription_rateTimes(self)

    def rateTaus(self):
        r"""rateTaus(EvolutionDescription self) -> DoubleVector"""
        return _QuantLib.EvolutionDescription_rateTaus(self)

    def evolutionTimes(self):
        r"""evolutionTimes(EvolutionDescription self) -> DoubleVector"""
        return _QuantLib.EvolutionDescription_evolutionTimes(self)

    def firstAliveRate(self):
        r"""firstAliveRate(EvolutionDescription self) -> UnsignedIntVector"""
        return _QuantLib.EvolutionDescription_firstAliveRate(self)

    def relevanceRates(self):
        r"""relevanceRates(EvolutionDescription self) -> UnsignedIntPairVector"""
        return _QuantLib.EvolutionDescription_relevanceRates(self)

    def numberOfRates(self):
        r"""numberOfRates(EvolutionDescription self) -> Size"""
        return _QuantLib.EvolutionDescription_numberOfRates(self)

    def numberOfSteps(self):
        r"""numberOfSteps(EvolutionDescription self) -> Size"""
        return _QuantLib.EvolutionDescription_numberOfSteps(self)
    __swig_destroy__ = _QuantLib.delete_EvolutionDescription

# Register EvolutionDescription in _QuantLib:
_QuantLib.EvolutionDescription_swigregister(EvolutionDescription)

def checkCompatibility(evolution, numeraires):
    r"""checkCompatibility(EvolutionDescription evolution, UnsignedIntVector numeraires)"""
    return _QuantLib.checkCompatibility(evolution, numeraires)

def isInTerminalMeasure(evolution, numeraires):
    r"""isInTerminalMeasure(EvolutionDescription evolution, UnsignedIntVector numeraires) -> bool"""
    return _QuantLib.isInTerminalMeasure(evolution, numeraires)

def isInMoneyMarketPlusMeasure(evolution, numeraires, offset=1):
    r"""isInMoneyMarketPlusMeasure(EvolutionDescription evolution, UnsignedIntVector numeraires, Size offset=1) -> bool"""
    return _QuantLib.isInMoneyMarketPlusMeasure(evolution, numeraires, offset)

def isInMoneyMarketMeasure(evolution, numeraires):
    r"""isInMoneyMarketMeasure(EvolutionDescription evolution, UnsignedIntVector numeraires) -> bool"""
    return _QuantLib.isInMoneyMarketMeasure(evolution, numeraires)

def terminalMeasure(evolution):
    r"""terminalMeasure(EvolutionDescription evolution) -> UnsignedIntVector"""
    return _QuantLib.terminalMeasure(evolution)

def moneyMarketPlusMeasure(evolution, offset=1):
    r"""moneyMarketPlusMeasure(EvolutionDescription evolution, Size offset=1) -> UnsignedIntVector"""
    return _QuantLib.moneyMarketPlusMeasure(evolution, offset)

def moneyMarketMeasure(evolution):
    r"""moneyMarketMeasure(EvolutionDescription evolution) -> UnsignedIntVector"""
    return _QuantLib.moneyMarketMeasure(evolution)
class MarketModel(object):
    r"""Proxy of C++ MarketModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def initialRates(self):
        r"""initialRates(MarketModel self) -> DoubleVector"""
        return _QuantLib.MarketModel_initialRates(self)

    def displacements(self):
        r"""displacements(MarketModel self) -> DoubleVector"""
        return _QuantLib.MarketModel_displacements(self)

    def evolution(self):
        r"""evolution(MarketModel self) -> EvolutionDescription"""
        return _QuantLib.MarketModel_evolution(self)

    def numberOfRates(self):
        r"""numberOfRates(MarketModel self) -> Size"""
        return _QuantLib.MarketModel_numberOfRates(self)

    def numberOfFactors(self):
        r"""numberOfFactors(MarketModel self) -> Size"""
        return _QuantLib.MarketModel_numberOfFactors(self)

    def numberOfSteps(self):
        r"""numberOfSteps(MarketModel self) -> Size"""
        return _QuantLib.MarketModel_numberOfSteps(self)

    def pseudoRoot(self, i):
        r"""pseudoRoot(MarketModel self, Size i) -> Matrix"""
        return _QuantLib.MarketModel_pseudoRoot(self, i)

    def covariance(self, i):
        r"""covariance(MarketModel self, Size i) -> Matrix"""
        return _QuantLib.MarketModel_covariance(self, i)

    def totalCovariance(self, endIndex):
        r"""totalCovariance(MarketModel self, Size endIndex) -> Matrix"""
        return _QuantLib.MarketModel_totalCovariance(self, endIndex)

    def timeDependentVolatility(self, i):
        r"""timeDependentVolatility(MarketModel self, Size i) -> DoubleVector"""
        return _QuantLib.MarketModel_timeDependentVolatility(self, i)
    __swig_destroy__ = _QuantLib.delete_MarketModel

# Register MarketModel in _QuantLib:
_QuantLib.MarketModel_swigregister(MarketModel)
class MarketModelFactory(object):
    r"""Proxy of C++ MarketModelFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(self, arg2, numberOfFactors):
        r"""create(MarketModelFactory self, EvolutionDescription arg2, Size numberOfFactors) -> ext::shared_ptr< MarketModel >"""
        return _QuantLib.MarketModelFactory_create(self, arg2, numberOfFactors)
    __swig_destroy__ = _QuantLib.delete_MarketModelFactory

# Register MarketModelFactory in _QuantLib:
_QuantLib.MarketModelFactory_swigregister(MarketModelFactory)
class PiecewiseConstantCorrelation(object):
    r"""Proxy of C++ PiecewiseConstantCorrelation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def times(self):
        r"""times(PiecewiseConstantCorrelation self) -> DoubleVector"""
        return _QuantLib.PiecewiseConstantCorrelation_times(self)

    def rateTimes(self):
        r"""rateTimes(PiecewiseConstantCorrelation self) -> DoubleVector"""
        return _QuantLib.PiecewiseConstantCorrelation_rateTimes(self)

    def correlations(self):
        r"""correlations(PiecewiseConstantCorrelation self) -> std::vector< Matrix,std::allocator< Matrix > > const &"""
        return _QuantLib.PiecewiseConstantCorrelation_correlations(self)

    def correlation(self, i):
        r"""correlation(PiecewiseConstantCorrelation self, Size i) -> Matrix"""
        return _QuantLib.PiecewiseConstantCorrelation_correlation(self, i)

    def numberOfRates(self):
        r"""numberOfRates(PiecewiseConstantCorrelation self) -> Size"""
        return _QuantLib.PiecewiseConstantCorrelation_numberOfRates(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseConstantCorrelation

# Register PiecewiseConstantCorrelation in _QuantLib:
_QuantLib.PiecewiseConstantCorrelation_swigregister(PiecewiseConstantCorrelation)
class ExponentialForwardCorrelation(PiecewiseConstantCorrelation):
    r"""Proxy of C++ ExponentialForwardCorrelation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ExponentialForwardCorrelation self, DoubleVector rateTimes, Real longTermCorr=0.5, Real beta=0.2, Real gamma=1.0, DoubleVector times={}) -> ExponentialForwardCorrelation"""
        _QuantLib.ExponentialForwardCorrelation_swiginit(self, _QuantLib.new_ExponentialForwardCorrelation(*args))
    __swig_destroy__ = _QuantLib.delete_ExponentialForwardCorrelation

# Register ExponentialForwardCorrelation in _QuantLib:
_QuantLib.ExponentialForwardCorrelation_swigregister(ExponentialForwardCorrelation)
class CurveState(object):
    r"""Proxy of C++ CurveState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def numberOfRates(self):
        r"""numberOfRates(CurveState self) -> Size"""
        return _QuantLib.CurveState_numberOfRates(self)

    def rateTimes(self):
        r"""rateTimes(CurveState self) -> DoubleVector"""
        return _QuantLib.CurveState_rateTimes(self)

    def rateTaus(self):
        r"""rateTaus(CurveState self) -> DoubleVector"""
        return _QuantLib.CurveState_rateTaus(self)

    def discountRatio(self, i, j):
        r"""discountRatio(CurveState self, Size i, Size j) -> Real"""
        return _QuantLib.CurveState_discountRatio(self, i, j)

    def forwardRate(self, i):
        r"""forwardRate(CurveState self, Size i) -> Rate"""
        return _QuantLib.CurveState_forwardRate(self, i)

    def coterminalSwapAnnuity(self, numeraire, i):
        r"""coterminalSwapAnnuity(CurveState self, Size numeraire, Size i) -> Rate"""
        return _QuantLib.CurveState_coterminalSwapAnnuity(self, numeraire, i)

    def coterminalSwapRate(self, i):
        r"""coterminalSwapRate(CurveState self, Size i) -> Rate"""
        return _QuantLib.CurveState_coterminalSwapRate(self, i)

    def cmSwapAnnuity(self, numeraire, i, spanningForwards):
        r"""cmSwapAnnuity(CurveState self, Size numeraire, Size i, Size spanningForwards) -> Rate"""
        return _QuantLib.CurveState_cmSwapAnnuity(self, numeraire, i, spanningForwards)

    def cmSwapRate(self, i, spanningForwards):
        r"""cmSwapRate(CurveState self, Size i, Size spanningForwards) -> Rate"""
        return _QuantLib.CurveState_cmSwapRate(self, i, spanningForwards)

    def forwardRates(self):
        r"""forwardRates(CurveState self) -> DoubleVector"""
        return _QuantLib.CurveState_forwardRates(self)

    def coterminalSwapRates(self):
        r"""coterminalSwapRates(CurveState self) -> DoubleVector"""
        return _QuantLib.CurveState_coterminalSwapRates(self)

    def cmSwapRates(self, spanningForwards):
        r"""cmSwapRates(CurveState self, Size spanningForwards) -> DoubleVector"""
        return _QuantLib.CurveState_cmSwapRates(self, spanningForwards)

    def swapRate(self, begin, end):
        r"""swapRate(CurveState self, Size begin, Size end) -> Rate"""
        return _QuantLib.CurveState_swapRate(self, begin, end)
    __swig_destroy__ = _QuantLib.delete_CurveState

# Register CurveState in _QuantLib:
_QuantLib.CurveState_swigregister(CurveState)
class LMMCurveState(CurveState):
    r"""Proxy of C++ LMMCurveState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rateTimes):
        r"""__init__(LMMCurveState self, DoubleVector rateTimes) -> LMMCurveState"""
        _QuantLib.LMMCurveState_swiginit(self, _QuantLib.new_LMMCurveState(rateTimes))

    def setOnForwardRates(self, fwdRates, firstValidIndex=0):
        r"""setOnForwardRates(LMMCurveState self, DoubleVector fwdRates, Size firstValidIndex=0)"""
        return _QuantLib.LMMCurveState_setOnForwardRates(self, fwdRates, firstValidIndex)

    def setOnDiscountRatios(self, discRatios, firstValidIndex=0):
        r"""setOnDiscountRatios(LMMCurveState self, DoubleVector discRatios, Size firstValidIndex=0)"""
        return _QuantLib.LMMCurveState_setOnDiscountRatios(self, discRatios, firstValidIndex)
    __swig_destroy__ = _QuantLib.delete_LMMCurveState

# Register LMMCurveState in _QuantLib:
_QuantLib.LMMCurveState_swigregister(LMMCurveState)
class LMMDriftCalculator(object):
    r"""Proxy of C++ LMMDriftCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pseudo, displacements, taus, numeraire, alive):
        r"""__init__(LMMDriftCalculator self, Matrix pseudo, DoubleVector displacements, DoubleVector taus, Size numeraire, Size alive) -> LMMDriftCalculator"""
        _QuantLib.LMMDriftCalculator_swiginit(self, _QuantLib.new_LMMDriftCalculator(pseudo, displacements, taus, numeraire, alive))

    def compute(self, *args):
        r"""
        compute(LMMDriftCalculator self, LMMCurveState cs, DoubleVector drifts)
        compute(LMMDriftCalculator self, DoubleVector fwds, DoubleVector drifts)
        """
        return _QuantLib.LMMDriftCalculator_compute(self, *args)

    def computePlain(self, *args):
        r"""
        computePlain(LMMDriftCalculator self, LMMCurveState cs, DoubleVector drifts)
        computePlain(LMMDriftCalculator self, DoubleVector fwds, DoubleVector drifts)
        """
        return _QuantLib.LMMDriftCalculator_computePlain(self, *args)

    def computeReduced(self, *args):
        r"""
        computeReduced(LMMDriftCalculator self, LMMCurveState cs, DoubleVector drifts)
        computeReduced(LMMDriftCalculator self, DoubleVector fwds, DoubleVector drifts)
        """
        return _QuantLib.LMMDriftCalculator_computeReduced(self, *args)
    __swig_destroy__ = _QuantLib.delete_LMMDriftCalculator

# Register LMMDriftCalculator in _QuantLib:
_QuantLib.LMMDriftCalculator_swigregister(LMMDriftCalculator)
class MarketModelEvolver(object):
    r"""Proxy of C++ MarketModelEvolver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def numeraires(self):
        r"""numeraires(MarketModelEvolver self) -> UnsignedIntVector"""
        return _QuantLib.MarketModelEvolver_numeraires(self)

    def startNewPath(self):
        r"""startNewPath(MarketModelEvolver self) -> Real"""
        return _QuantLib.MarketModelEvolver_startNewPath(self)

    def advanceStep(self):
        r"""advanceStep(MarketModelEvolver self) -> Real"""
        return _QuantLib.MarketModelEvolver_advanceStep(self)

    def currentStep(self):
        r"""currentStep(MarketModelEvolver self) -> Size"""
        return _QuantLib.MarketModelEvolver_currentStep(self)

    def currentState(self):
        r"""currentState(MarketModelEvolver self) -> CurveState"""
        return _QuantLib.MarketModelEvolver_currentState(self)

    def setInitialState(self, arg2):
        r"""setInitialState(MarketModelEvolver self, CurveState arg2)"""
        return _QuantLib.MarketModelEvolver_setInitialState(self, arg2)
    __swig_destroy__ = _QuantLib.delete_MarketModelEvolver

# Register MarketModelEvolver in _QuantLib:
_QuantLib.MarketModelEvolver_swigregister(MarketModelEvolver)
class LogNormalFwdRateIpc(MarketModelEvolver):
    r"""Proxy of C++ LogNormalFwdRateIpc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, model, factory, numeraires, initialStep=0):
        r"""__init__(LogNormalFwdRateIpc self, ext::shared_ptr< MarketModel > const & model, BrownianGeneratorFactory factory, UnsignedIntVector numeraires, Size initialStep=0) -> LogNormalFwdRateIpc"""
        _QuantLib.LogNormalFwdRateIpc_swiginit(self, _QuantLib.new_LogNormalFwdRateIpc(model, factory, numeraires, initialStep))
    __swig_destroy__ = _QuantLib.delete_LogNormalFwdRateIpc

# Register LogNormalFwdRateIpc in _QuantLib:
_QuantLib.LogNormalFwdRateIpc_swigregister(LogNormalFwdRateIpc)
class AbcdVol(MarketModel):
    r"""Proxy of C++ AbcdVol class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, a, b, c, d, ks, corr, evolution, numberOfFactors, initialRates, displacements):
        r"""__init__(AbcdVol self, Real a, Real b, Real c, Real d, DoubleVector ks, ext::shared_ptr< PiecewiseConstantCorrelation > const & corr, EvolutionDescription evolution, Size numberOfFactors, DoubleVector initialRates, DoubleVector displacements) -> AbcdVol"""
        _QuantLib.AbcdVol_swiginit(self, _QuantLib.new_AbcdVol(a, b, c, d, ks, corr, evolution, numberOfFactors, initialRates, displacements))
    __swig_destroy__ = _QuantLib.delete_AbcdVol

# Register AbcdVol in _QuantLib:
_QuantLib.AbcdVol_swigregister(AbcdVol)
class AbcdMathFunction(object):
    r"""Proxy of C++ AbcdMathFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(AbcdMathFunction self, Real a=0.002, Real b=0.001, Real c=0.16, Real d=0.0005) -> AbcdMathFunction
        __init__(AbcdMathFunction self, DoubleVector abcd) -> AbcdMathFunction
        """
        _QuantLib.AbcdMathFunction_swiginit(self, _QuantLib.new_AbcdMathFunction(*args))

    def __call__(self, t):
        r"""__call__(AbcdMathFunction self, Time t) -> Real"""
        return _QuantLib.AbcdMathFunction___call__(self, t)

    def maximumLocation(self):
        r"""maximumLocation(AbcdMathFunction self) -> Time"""
        return _QuantLib.AbcdMathFunction_maximumLocation(self)

    def maximumValue(self):
        r"""maximumValue(AbcdMathFunction self) -> Real"""
        return _QuantLib.AbcdMathFunction_maximumValue(self)

    def longTermValue(self):
        r"""longTermValue(AbcdMathFunction self) -> Real"""
        return _QuantLib.AbcdMathFunction_longTermValue(self)

    def derivative(self, t):
        r"""derivative(AbcdMathFunction self, Time t) -> Real"""
        return _QuantLib.AbcdMathFunction_derivative(self, t)

    def primitive(self, t):
        r"""primitive(AbcdMathFunction self, Time t) -> Real"""
        return _QuantLib.AbcdMathFunction_primitive(self, t)

    def definiteIntegral(self, t1, t2):
        r"""definiteIntegral(AbcdMathFunction self, Time t1, Time t2) -> Real"""
        return _QuantLib.AbcdMathFunction_definiteIntegral(self, t1, t2)

    def a(self):
        r"""a(AbcdMathFunction self) -> Real"""
        return _QuantLib.AbcdMathFunction_a(self)

    def b(self):
        r"""b(AbcdMathFunction self) -> Real"""
        return _QuantLib.AbcdMathFunction_b(self)

    def c(self):
        r"""c(AbcdMathFunction self) -> Real"""
        return _QuantLib.AbcdMathFunction_c(self)

    def d(self):
        r"""d(AbcdMathFunction self) -> Real"""
        return _QuantLib.AbcdMathFunction_d(self)

    def coefficients(self):
        r"""coefficients(AbcdMathFunction self) -> DoubleVector"""
        return _QuantLib.AbcdMathFunction_coefficients(self)

    def derivativeCoefficients(self):
        r"""derivativeCoefficients(AbcdMathFunction self) -> DoubleVector"""
        return _QuantLib.AbcdMathFunction_derivativeCoefficients(self)

    def definiteIntegralCoefficients(self, t, t2):
        r"""definiteIntegralCoefficients(AbcdMathFunction self, Time t, Time t2) -> DoubleVector"""
        return _QuantLib.AbcdMathFunction_definiteIntegralCoefficients(self, t, t2)

    def definiteDerivativeCoefficients(self, t, t2):
        r"""definiteDerivativeCoefficients(AbcdMathFunction self, Time t, Time t2) -> DoubleVector"""
        return _QuantLib.AbcdMathFunction_definiteDerivativeCoefficients(self, t, t2)

    @staticmethod
    def validate(a, b, c, d):
        r"""validate(Real a, Real b, Real c, Real d)"""
        return _QuantLib.AbcdMathFunction_validate(a, b, c, d)
    __swig_destroy__ = _QuantLib.delete_AbcdMathFunction

# Register AbcdMathFunction in _QuantLib:
_QuantLib.AbcdMathFunction_swigregister(AbcdMathFunction)
class AbcdFunction(AbcdMathFunction):
    r"""Proxy of C++ AbcdFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, a=-0.06, b=0.17, c=0.54, d=0.17):
        r"""__init__(AbcdFunction self, Real a=-0.06, Real b=0.17, Real c=0.54, Real d=0.17) -> AbcdFunction"""
        _QuantLib.AbcdFunction_swiginit(self, _QuantLib.new_AbcdFunction(a, b, c, d))

    def maximumVolatility(self):
        r"""maximumVolatility(AbcdFunction self) -> Real"""
        return _QuantLib.AbcdFunction_maximumVolatility(self)

    def shortTermVolatility(self):
        r"""shortTermVolatility(AbcdFunction self) -> Real"""
        return _QuantLib.AbcdFunction_shortTermVolatility(self)

    def longTermVolatility(self):
        r"""longTermVolatility(AbcdFunction self) -> Real"""
        return _QuantLib.AbcdFunction_longTermVolatility(self)

    def covariance(self, *args):
        r"""
        covariance(AbcdFunction self, Time t, Time T, Time S) -> Real
        covariance(AbcdFunction self, Time t1, Time t2, Time T, Time S) -> Real
        """
        return _QuantLib.AbcdFunction_covariance(self, *args)

    def volatility(self, tMin, tMax, T):
        r"""volatility(AbcdFunction self, Time tMin, Time tMax, Time T) -> Real"""
        return _QuantLib.AbcdFunction_volatility(self, tMin, tMax, T)

    def variance(self, tMin, tMax, T):
        r"""variance(AbcdFunction self, Time tMin, Time tMax, Time T) -> Real"""
        return _QuantLib.AbcdFunction_variance(self, tMin, tMax, T)

    def instantaneousVolatility(self, t, T):
        r"""instantaneousVolatility(AbcdFunction self, Time t, Time T) -> Real"""
        return _QuantLib.AbcdFunction_instantaneousVolatility(self, t, T)

    def instantaneousVariance(self, t, T):
        r"""instantaneousVariance(AbcdFunction self, Time t, Time T) -> Real"""
        return _QuantLib.AbcdFunction_instantaneousVariance(self, t, T)

    def instantaneousCovariance(self, u, T, S):
        r"""instantaneousCovariance(AbcdFunction self, Time u, Time T, Time S) -> Real"""
        return _QuantLib.AbcdFunction_instantaneousCovariance(self, u, T, S)

    def primitive(self, t, T, S):
        r"""primitive(AbcdFunction self, Time t, Time T, Time S) -> Real"""
        return _QuantLib.AbcdFunction_primitive(self, t, T, S)
    __swig_destroy__ = _QuantLib.delete_AbcdFunction

# Register AbcdFunction in _QuantLib:
_QuantLib.AbcdFunction_swigregister(AbcdFunction)
class ContinuousFloatingLookbackOption(OneAssetOption):
    r"""Proxy of C++ ContinuousFloatingLookbackOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, currentMinmax, payoff, exercise):
        r"""__init__(ContinuousFloatingLookbackOption self, Real currentMinmax, ext::shared_ptr< TypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousFloatingLookbackOption"""
        _QuantLib.ContinuousFloatingLookbackOption_swiginit(self, _QuantLib.new_ContinuousFloatingLookbackOption(currentMinmax, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ContinuousFloatingLookbackOption

# Register ContinuousFloatingLookbackOption in _QuantLib:
_QuantLib.ContinuousFloatingLookbackOption_swigregister(ContinuousFloatingLookbackOption)
class ContinuousFixedLookbackOption(OneAssetOption):
    r"""Proxy of C++ ContinuousFixedLookbackOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, currentMinmax, payoff, exercise):
        r"""__init__(ContinuousFixedLookbackOption self, Real currentMinmax, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousFixedLookbackOption"""
        _QuantLib.ContinuousFixedLookbackOption_swiginit(self, _QuantLib.new_ContinuousFixedLookbackOption(currentMinmax, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ContinuousFixedLookbackOption

# Register ContinuousFixedLookbackOption in _QuantLib:
_QuantLib.ContinuousFixedLookbackOption_swigregister(ContinuousFixedLookbackOption)
class ContinuousPartialFloatingLookbackOption(ContinuousFloatingLookbackOption):
    r"""Proxy of C++ ContinuousPartialFloatingLookbackOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, currentMinmax, lambda_parameter, lookbackPeriodEnd, payoff, exercise):
        r"""__init__(ContinuousPartialFloatingLookbackOption self, Real currentMinmax, Real lambda_parameter, Date lookbackPeriodEnd, ext::shared_ptr< TypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousPartialFloatingLookbackOption"""
        _QuantLib.ContinuousPartialFloatingLookbackOption_swiginit(self, _QuantLib.new_ContinuousPartialFloatingLookbackOption(currentMinmax, lambda_parameter, lookbackPeriodEnd, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ContinuousPartialFloatingLookbackOption

# Register ContinuousPartialFloatingLookbackOption in _QuantLib:
_QuantLib.ContinuousPartialFloatingLookbackOption_swigregister(ContinuousPartialFloatingLookbackOption)
class ContinuousPartialFixedLookbackOption(ContinuousFixedLookbackOption):
    r"""Proxy of C++ ContinuousPartialFixedLookbackOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lookbackPeriodStart, payoff, exercise):
        r"""__init__(ContinuousPartialFixedLookbackOption self, Date lookbackPeriodStart, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousPartialFixedLookbackOption"""
        _QuantLib.ContinuousPartialFixedLookbackOption_swiginit(self, _QuantLib.new_ContinuousPartialFixedLookbackOption(lookbackPeriodStart, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ContinuousPartialFixedLookbackOption

# Register ContinuousPartialFixedLookbackOption in _QuantLib:
_QuantLib.ContinuousPartialFixedLookbackOption_swigregister(ContinuousPartialFixedLookbackOption)
class AnalyticContinuousFloatingLookbackEngine(PricingEngine):
    r"""Proxy of C++ AnalyticContinuousFloatingLookbackEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        r"""__init__(AnalyticContinuousFloatingLookbackEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousFloatingLookbackEngine"""
        _QuantLib.AnalyticContinuousFloatingLookbackEngine_swiginit(self, _QuantLib.new_AnalyticContinuousFloatingLookbackEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousFloatingLookbackEngine

# Register AnalyticContinuousFloatingLookbackEngine in _QuantLib:
_QuantLib.AnalyticContinuousFloatingLookbackEngine_swigregister(AnalyticContinuousFloatingLookbackEngine)
class AnalyticContinuousFixedLookbackEngine(PricingEngine):
    r"""Proxy of C++ AnalyticContinuousFixedLookbackEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        r"""__init__(AnalyticContinuousFixedLookbackEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousFixedLookbackEngine"""
        _QuantLib.AnalyticContinuousFixedLookbackEngine_swiginit(self, _QuantLib.new_AnalyticContinuousFixedLookbackEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousFixedLookbackEngine

# Register AnalyticContinuousFixedLookbackEngine in _QuantLib:
_QuantLib.AnalyticContinuousFixedLookbackEngine_swigregister(AnalyticContinuousFixedLookbackEngine)
class AnalyticContinuousPartialFloatingLookbackEngine(PricingEngine):
    r"""Proxy of C++ AnalyticContinuousPartialFloatingLookbackEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        r"""__init__(AnalyticContinuousPartialFloatingLookbackEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousPartialFloatingLookbackEngine"""
        _QuantLib.AnalyticContinuousPartialFloatingLookbackEngine_swiginit(self, _QuantLib.new_AnalyticContinuousPartialFloatingLookbackEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousPartialFloatingLookbackEngine

# Register AnalyticContinuousPartialFloatingLookbackEngine in _QuantLib:
_QuantLib.AnalyticContinuousPartialFloatingLookbackEngine_swigregister(AnalyticContinuousPartialFloatingLookbackEngine)
class AnalyticContinuousPartialFixedLookbackEngine(PricingEngine):
    r"""Proxy of C++ AnalyticContinuousPartialFixedLookbackEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        r"""__init__(AnalyticContinuousPartialFixedLookbackEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousPartialFixedLookbackEngine"""
        _QuantLib.AnalyticContinuousPartialFixedLookbackEngine_swiginit(self, _QuantLib.new_AnalyticContinuousPartialFixedLookbackEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousPartialFixedLookbackEngine

# Register AnalyticContinuousPartialFixedLookbackEngine in _QuantLib:
_QuantLib.AnalyticContinuousPartialFixedLookbackEngine_swigregister(AnalyticContinuousPartialFixedLookbackEngine)

def getCovariance(volatilities, correlations):
    r"""getCovariance(Array volatilities, Matrix correlations) -> Matrix"""
    return _QuantLib.getCovariance(volatilities, correlations)
class Path(object):
    r"""Proxy of C++ Path class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def __len__(self):
        r"""__len__(Path self) -> Size"""
        return _QuantLib.Path___len__(self)

    def value(self, i):
        r"""value(Path self, Size i) -> Real"""
        return _QuantLib.Path_value(self, i)

    def front(self):
        r"""front(Path self) -> Real"""
        return _QuantLib.Path_front(self)

    def back(self):
        r"""back(Path self) -> Real"""
        return _QuantLib.Path_back(self)

    def time(self, i):
        r"""time(Path self, Size i) -> Time"""
        return _QuantLib.Path_time(self, i)

    def __getitem__(self, i):
        r"""__getitem__(Path self, Integer i) -> Real"""
        return _QuantLib.Path___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_Path

# Register Path in _QuantLib:
_QuantLib.Path_swigregister(Path)
class SamplePath(object):
    r"""Proxy of C++ Sample< Path > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def value(self):
        r"""value(SamplePath self) -> Path"""
        return _QuantLib.SamplePath_value(self)

    def weight(self):
        r"""weight(SamplePath self) -> Real"""
        return _QuantLib.SamplePath_weight(self)
    __swig_destroy__ = _QuantLib.delete_SamplePath

# Register SamplePath in _QuantLib:
_QuantLib.SamplePath_swigregister(SamplePath)
class GaussianPathGenerator(object):
    r"""Proxy of C++ PathGenerator< GaussianRandomSequenceGenerator > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(GaussianPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, Time length, Size timeSteps, GaussianRandomSequenceGenerator generator, bool brownianBridge) -> GaussianPathGenerator
        __init__(GaussianPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, TimeGrid timeGrid, GaussianRandomSequenceGenerator generator, bool brownianBridge) -> GaussianPathGenerator
        """
        _QuantLib.GaussianPathGenerator_swiginit(self, _QuantLib.new_GaussianPathGenerator(*args))

    def next(self):
        r"""next(GaussianPathGenerator self) -> SamplePath"""
        return _QuantLib.GaussianPathGenerator_next(self)

    def antithetic(self):
        r"""antithetic(GaussianPathGenerator self) -> SamplePath"""
        return _QuantLib.GaussianPathGenerator_antithetic(self)

    def size(self):
        r"""size(GaussianPathGenerator self) -> Size"""
        return _QuantLib.GaussianPathGenerator_size(self)

    def timeGrid(self):
        r"""timeGrid(GaussianPathGenerator self) -> TimeGrid"""
        return _QuantLib.GaussianPathGenerator_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_GaussianPathGenerator

# Register GaussianPathGenerator in _QuantLib:
_QuantLib.GaussianPathGenerator_swigregister(GaussianPathGenerator)
class GaussianSobolPathGenerator(object):
    r"""Proxy of C++ PathGenerator< GaussianLowDiscrepancySequenceGenerator > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(GaussianSobolPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, Time length, Size timeSteps, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge) -> GaussianSobolPathGenerator
        __init__(GaussianSobolPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, TimeGrid timeGrid, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge) -> GaussianSobolPathGenerator
        """
        _QuantLib.GaussianSobolPathGenerator_swiginit(self, _QuantLib.new_GaussianSobolPathGenerator(*args))

    def next(self):
        r"""next(GaussianSobolPathGenerator self) -> SamplePath"""
        return _QuantLib.GaussianSobolPathGenerator_next(self)

    def antithetic(self):
        r"""antithetic(GaussianSobolPathGenerator self) -> SamplePath"""
        return _QuantLib.GaussianSobolPathGenerator_antithetic(self)

    def size(self):
        r"""size(GaussianSobolPathGenerator self) -> Size"""
        return _QuantLib.GaussianSobolPathGenerator_size(self)

    def timeGrid(self):
        r"""timeGrid(GaussianSobolPathGenerator self) -> TimeGrid"""
        return _QuantLib.GaussianSobolPathGenerator_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_GaussianSobolPathGenerator

# Register GaussianSobolPathGenerator in _QuantLib:
_QuantLib.GaussianSobolPathGenerator_swigregister(GaussianSobolPathGenerator)
class InvCumulativeMersenneTwisterPathGenerator(object):
    r"""Proxy of C++ PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(InvCumulativeMersenneTwisterPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, Time length, Size timeSteps, InvCumulativeMersenneTwisterGaussianRsg generator, bool brownianBridge) -> InvCumulativeMersenneTwisterPathGenerator
        __init__(InvCumulativeMersenneTwisterPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, TimeGrid timeGrid, InvCumulativeMersenneTwisterGaussianRsg generator, bool brownianBridge) -> InvCumulativeMersenneTwisterPathGenerator
        """
        _QuantLib.InvCumulativeMersenneTwisterPathGenerator_swiginit(self, _QuantLib.new_InvCumulativeMersenneTwisterPathGenerator(*args))

    def next(self):
        r"""next(InvCumulativeMersenneTwisterPathGenerator self) -> SamplePath"""
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_next(self)

    def antithetic(self):
        r"""antithetic(InvCumulativeMersenneTwisterPathGenerator self) -> SamplePath"""
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_antithetic(self)

    def size(self):
        r"""size(InvCumulativeMersenneTwisterPathGenerator self) -> Size"""
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_size(self)

    def timeGrid(self):
        r"""timeGrid(InvCumulativeMersenneTwisterPathGenerator self) -> TimeGrid"""
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterPathGenerator

# Register InvCumulativeMersenneTwisterPathGenerator in _QuantLib:
_QuantLib.InvCumulativeMersenneTwisterPathGenerator_swigregister(InvCumulativeMersenneTwisterPathGenerator)
class MultiPath(object):
    r"""Proxy of C++ MultiPath class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def __len__(self):
        r"""__len__(MultiPath self) -> Size"""
        return _QuantLib.MultiPath___len__(self)

    def assetNumber(self):
        r"""assetNumber(MultiPath self) -> Size"""
        return _QuantLib.MultiPath_assetNumber(self)

    def at(self, j):
        r"""at(MultiPath self, Size j) -> Path"""
        return _QuantLib.MultiPath_at(self, j)

    def __getitem__(self, i):
        r"""__getitem__(MultiPath self, Integer i) -> Path"""
        return _QuantLib.MultiPath___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_MultiPath

# Register MultiPath in _QuantLib:
_QuantLib.MultiPath_swigregister(MultiPath)
class SampleMultiPath(object):
    r"""Proxy of C++ Sample< MultiPath > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def value(self):
        r"""value(SampleMultiPath self) -> MultiPath"""
        return _QuantLib.SampleMultiPath_value(self)

    def weight(self):
        r"""weight(SampleMultiPath self) -> Real"""
        return _QuantLib.SampleMultiPath_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleMultiPath

# Register SampleMultiPath in _QuantLib:
_QuantLib.SampleMultiPath_swigregister(SampleMultiPath)
class GaussianMultiPathGenerator(object):
    r"""Proxy of C++ MultiPathGenerator< GaussianRandomSequenceGenerator > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(GaussianMultiPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, TimeGrid timeGrid, GaussianRandomSequenceGenerator generator, bool brownianBridge=False) -> GaussianMultiPathGenerator
        __init__(GaussianMultiPathGenerator self, ext::shared_ptr< StochasticProcess > const & process, DoubleVector times, GaussianRandomSequenceGenerator generator, bool brownianBridge=False) -> GaussianMultiPathGenerator
        """
        _QuantLib.GaussianMultiPathGenerator_swiginit(self, _QuantLib.new_GaussianMultiPathGenerator(*args))

    def next(self):
        r"""next(GaussianMultiPathGenerator self) -> SampleMultiPath"""
        return _QuantLib.GaussianMultiPathGenerator_next(self)

    def antithetic(self):
        r"""antithetic(GaussianMultiPathGenerator self) -> SampleMultiPath"""
        return _QuantLib.GaussianMultiPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianMultiPathGenerator

# Register GaussianMultiPathGenerator in _QuantLib:
_QuantLib.GaussianMultiPathGenerator_swigregister(GaussianMultiPathGenerator)
class GaussianSobolMultiPathGenerator(object):
    r"""Proxy of C++ MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(GaussianSobolMultiPathGenerator self, ext::shared_ptr< StochasticProcess > const & arg2, TimeGrid timeGrid, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge=False) -> GaussianSobolMultiPathGenerator
        __init__(GaussianSobolMultiPathGenerator self, ext::shared_ptr< StochasticProcess > const & process, DoubleVector times, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge=False) -> GaussianSobolMultiPathGenerator
        """
        _QuantLib.GaussianSobolMultiPathGenerator_swiginit(self, _QuantLib.new_GaussianSobolMultiPathGenerator(*args))

    def next(self):
        r"""next(GaussianSobolMultiPathGenerator self) -> SampleMultiPath"""
        return _QuantLib.GaussianSobolMultiPathGenerator_next(self)

    def antithetic(self):
        r"""antithetic(GaussianSobolMultiPathGenerator self) -> SampleMultiPath"""
        return _QuantLib.GaussianSobolMultiPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianSobolMultiPathGenerator

# Register GaussianSobolMultiPathGenerator in _QuantLib:
_QuantLib.GaussianSobolMultiPathGenerator_swigregister(GaussianSobolMultiPathGenerator)
class BrownianBridge(object):
    r"""Proxy of C++ BrownianBridge class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(BrownianBridge self, Size steps) -> BrownianBridge
        __init__(BrownianBridge self, DoubleVector times) -> BrownianBridge
        __init__(BrownianBridge self, TimeGrid timeGrid) -> BrownianBridge
        """
        _QuantLib.BrownianBridge_swiginit(self, _QuantLib.new_BrownianBridge(*args))

    def size(self):
        r"""size(BrownianBridge self) -> Size"""
        return _QuantLib.BrownianBridge_size(self)

    def times(self):
        r"""times(BrownianBridge self) -> DoubleVector"""
        return _QuantLib.BrownianBridge_times(self)

    def leftWeight(self):
        r"""leftWeight(BrownianBridge self) -> DoubleVector"""
        return _QuantLib.BrownianBridge_leftWeight(self)

    def rightWeight(self):
        r"""rightWeight(BrownianBridge self) -> DoubleVector"""
        return _QuantLib.BrownianBridge_rightWeight(self)

    def stdDeviation(self):
        r"""stdDeviation(BrownianBridge self) -> DoubleVector"""
        return _QuantLib.BrownianBridge_stdDeviation(self)

    def transform(self, input):
        r"""transform(BrownianBridge self, DoubleVector input) -> DoubleVector"""
        return _QuantLib.BrownianBridge_transform(self, input)

    def bridgeIndex(self):
        r"""bridgeIndex(BrownianBridge self) -> UnsignedIntVector"""
        return _QuantLib.BrownianBridge_bridgeIndex(self)

    def leftIndex(self):
        r"""leftIndex(BrownianBridge self) -> UnsignedIntVector"""
        return _QuantLib.BrownianBridge_leftIndex(self)

    def rightIndex(self):
        r"""rightIndex(BrownianBridge self) -> UnsignedIntVector"""
        return _QuantLib.BrownianBridge_rightIndex(self)
    __swig_destroy__ = _QuantLib.delete_BrownianBridge

# Register BrownianBridge in _QuantLib:
_QuantLib.BrownianBridge_swigregister(BrownianBridge)
class RungeKutta(object):
    r"""Proxy of C++ AdaptiveRungeKutta< Real > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, eps=1.0e-6, h1=1.0e-4, hmin=0.0):
        r"""__init__(RungeKutta self, Real const eps=1.0e-6, Real const h1=1.0e-4, Real const hmin=0.0) -> RungeKutta"""
        _QuantLib.RungeKutta_swiginit(self, _QuantLib.new_RungeKutta(eps, h1, hmin))

    def __call__(self, *args):
        r"""
        __call__(RungeKutta self, PyObject * fct, double y1, Real x1, Real x2) -> double
        __call__(RungeKutta self, PyObject * fct, DoubleVector y1, Real x1, Real x2) -> DoubleVector
        """
        return _QuantLib.RungeKutta___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_RungeKutta

# Register RungeKutta in _QuantLib:
_QuantLib.RungeKutta_swigregister(RungeKutta)
class DefaultBoundaryCondition(object):
    r"""Proxy of C++ DefaultBoundaryCondition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    NoSide = _QuantLib.DefaultBoundaryCondition_NoSide
    
    Upper = _QuantLib.DefaultBoundaryCondition_Upper
    
    Lower = _QuantLib.DefaultBoundaryCondition_Lower
    
    __swig_destroy__ = _QuantLib.delete_DefaultBoundaryCondition

# Register DefaultBoundaryCondition in _QuantLib:
_QuantLib.DefaultBoundaryCondition_swigregister(DefaultBoundaryCondition)
class NeumannBC(DefaultBoundaryCondition):
    r"""Proxy of C++ NeumannBC class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, value, side):
        r"""__init__(NeumannBC self, Real value, DefaultBoundaryCondition::Side side) -> NeumannBC"""
        _QuantLib.NeumannBC_swiginit(self, _QuantLib.new_NeumannBC(value, side))
    __swig_destroy__ = _QuantLib.delete_NeumannBC

# Register NeumannBC in _QuantLib:
_QuantLib.NeumannBC_swigregister(NeumannBC)
class DirichletBC(DefaultBoundaryCondition):
    r"""Proxy of C++ DirichletBC class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, value, side):
        r"""__init__(DirichletBC self, Real value, DefaultBoundaryCondition::Side side) -> DirichletBC"""
        _QuantLib.DirichletBC_swiginit(self, _QuantLib.new_DirichletBC(value, side))
    __swig_destroy__ = _QuantLib.delete_DirichletBC

# Register DirichletBC in _QuantLib:
_QuantLib.DirichletBC_swigregister(DirichletBC)
class TridiagonalOperator(object):
    r"""Proxy of C++ TridiagonalOperator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, low, mid, high):
        r"""__init__(TridiagonalOperator self, Array low, Array mid, Array high) -> TridiagonalOperator"""
        _QuantLib.TridiagonalOperator_swiginit(self, _QuantLib.new_TridiagonalOperator(low, mid, high))

    def solveFor(self, rhs):
        r"""solveFor(TridiagonalOperator self, Array rhs) -> Array"""
        return _QuantLib.TridiagonalOperator_solveFor(self, rhs)

    def applyTo(self, v):
        r"""applyTo(TridiagonalOperator self, Array v) -> Array"""
        return _QuantLib.TridiagonalOperator_applyTo(self, v)

    def size(self):
        r"""size(TridiagonalOperator self) -> Size"""
        return _QuantLib.TridiagonalOperator_size(self)

    def setFirstRow(self, arg2, arg3):
        r"""setFirstRow(TridiagonalOperator self, Real arg2, Real arg3)"""
        return _QuantLib.TridiagonalOperator_setFirstRow(self, arg2, arg3)

    def setMidRow(self, arg2, arg3, arg4, arg5):
        r"""setMidRow(TridiagonalOperator self, Size arg2, Real arg3, Real arg4, Real arg5)"""
        return _QuantLib.TridiagonalOperator_setMidRow(self, arg2, arg3, arg4, arg5)

    def setMidRows(self, arg2, arg3, arg4):
        r"""setMidRows(TridiagonalOperator self, Real arg2, Real arg3, Real arg4)"""
        return _QuantLib.TridiagonalOperator_setMidRows(self, arg2, arg3, arg4)

    def setLastRow(self, arg2, arg3):
        r"""setLastRow(TridiagonalOperator self, Real arg2, Real arg3)"""
        return _QuantLib.TridiagonalOperator_setLastRow(self, arg2, arg3)

    @staticmethod
    def identity(size):
        r"""identity(Size size) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator_identity(size)

    def __add__(self, O):
        r"""__add__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___add__(self, O)

    def __sub__(self, O):
        r"""__sub__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___sub__(self, O)

    def __mul__(self, a):
        r"""__mul__(TridiagonalOperator self, Real a) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___mul__(self, a)

    def __div__(self, a):
        r"""__div__(TridiagonalOperator self, Real a) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___div__(self, a)

    def __iadd__(self, O):
        r"""__iadd__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___iadd__(self, O)

    def __isub__(self, O):
        r"""__isub__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___isub__(self, O)

    def __imul__(self, a):
        r"""__imul__(TridiagonalOperator self, Real a) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___imul__(self, a)

    def __rmul__(self, a):
        r"""__rmul__(TridiagonalOperator self, Real a) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___rmul__(self, a)

    def __idiv__(self, a):
        r"""__idiv__(TridiagonalOperator self, Real a) -> TridiagonalOperator"""
        return _QuantLib.TridiagonalOperator___idiv__(self, a)
    __swig_destroy__ = _QuantLib.delete_TridiagonalOperator

# Register TridiagonalOperator in _QuantLib:
_QuantLib.TridiagonalOperator_swigregister(TridiagonalOperator)
class DPlus(TridiagonalOperator):
    r"""Proxy of C++ DPlus class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        r"""__init__(DPlus self, Size gridPoints, Real h) -> DPlus"""
        _QuantLib.DPlus_swiginit(self, _QuantLib.new_DPlus(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DPlus

# Register DPlus in _QuantLib:
_QuantLib.DPlus_swigregister(DPlus)
class DMinus(TridiagonalOperator):
    r"""Proxy of C++ DMinus class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        r"""__init__(DMinus self, Size gridPoints, Real h) -> DMinus"""
        _QuantLib.DMinus_swiginit(self, _QuantLib.new_DMinus(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DMinus

# Register DMinus in _QuantLib:
_QuantLib.DMinus_swigregister(DMinus)
class DZero(TridiagonalOperator):
    r"""Proxy of C++ DZero class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        r"""__init__(DZero self, Size gridPoints, Real h) -> DZero"""
        _QuantLib.DZero_swiginit(self, _QuantLib.new_DZero(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DZero

# Register DZero in _QuantLib:
_QuantLib.DZero_swigregister(DZero)
class DPlusDMinus(TridiagonalOperator):
    r"""Proxy of C++ DPlusDMinus class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        r"""__init__(DPlusDMinus self, Size gridPoints, Real h) -> DPlusDMinus"""
        _QuantLib.DPlusDMinus_swiginit(self, _QuantLib.new_DPlusDMinus(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DPlusDMinus

# Register DPlusDMinus in _QuantLib:
_QuantLib.DPlusDMinus_swigregister(DPlusDMinus)
class SampledCurve(object):
    r"""Proxy of C++ SampledCurve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SampledCurve self) -> SampledCurve
        __init__(SampledCurve self, Array arg2) -> SampledCurve
        """
        _QuantLib.SampledCurve_swiginit(self, _QuantLib.new_SampledCurve(*args))

    def grid(self):
        r"""grid(SampledCurve self) -> Array"""
        return _QuantLib.SampledCurve_grid(self)

    def values(self):
        r"""values(SampledCurve self) -> Array"""
        return _QuantLib.SampledCurve_values(self)

    def gridValue(self, i):
        r"""gridValue(SampledCurve self, Size i) -> Real"""
        return _QuantLib.SampledCurve_gridValue(self, i)

    def value(self, i):
        r"""value(SampledCurve self, Size i) -> Real"""
        return _QuantLib.SampledCurve_value(self, i)

    def size(self):
        r"""size(SampledCurve self) -> Size"""
        return _QuantLib.SampledCurve_size(self)

    def empty(self):
        r"""empty(SampledCurve self) -> bool"""
        return _QuantLib.SampledCurve_empty(self)

    def setGrid(self, arg2):
        r"""setGrid(SampledCurve self, Array arg2)"""
        return _QuantLib.SampledCurve_setGrid(self, arg2)

    def setValues(self, arg2):
        r"""setValues(SampledCurve self, Array arg2)"""
        return _QuantLib.SampledCurve_setValues(self, arg2)

    def swap(self, arg2):
        r"""swap(SampledCurve self, SampledCurve arg2)"""
        return _QuantLib.SampledCurve_swap(self, arg2)

    def setLogGrid(self, min, max):
        r"""setLogGrid(SampledCurve self, Real min, Real max)"""
        return _QuantLib.SampledCurve_setLogGrid(self, min, max)

    def regridLogGrid(self, min, max):
        r"""regridLogGrid(SampledCurve self, Real min, Real max)"""
        return _QuantLib.SampledCurve_regridLogGrid(self, min, max)

    def shiftGrid(self, s):
        r"""shiftGrid(SampledCurve self, Real s)"""
        return _QuantLib.SampledCurve_shiftGrid(self, s)

    def scaleGrid(self, s):
        r"""scaleGrid(SampledCurve self, Real s)"""
        return _QuantLib.SampledCurve_scaleGrid(self, s)

    def regrid(self, arg2):
        r"""regrid(SampledCurve self, Array arg2)"""
        return _QuantLib.SampledCurve_regrid(self, arg2)
    __swig_destroy__ = _QuantLib.delete_SampledCurve

# Register SampledCurve in _QuantLib:
_QuantLib.SampledCurve_swigregister(SampledCurve)
class HestonSLVProcess(StochasticProcess):
    r"""Proxy of C++ HestonSLVProcess class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, hestonProcess, leverageFct, mixingFactor=1.0):
        r"""__init__(HestonSLVProcess self, ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< LocalVolTermStructure > const & leverageFct, Real const mixingFactor=1.0) -> HestonSLVProcess"""
        _QuantLib.HestonSLVProcess_swiginit(self, _QuantLib.new_HestonSLVProcess(hestonProcess, leverageFct, mixingFactor))
    __swig_destroy__ = _QuantLib.delete_HestonSLVProcess

# Register HestonSLVProcess in _QuantLib:
_QuantLib.HestonSLVProcess_swigregister(HestonSLVProcess)
class HestonSLVMCModel(object):
    r"""Proxy of C++ HestonSLVMCModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(HestonSLVMCModel self, ext::shared_ptr< LocalVolTermStructure > const & localVol, ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< BrownianGeneratorFactory > const & brownianGeneratorFactory, Date endDate, Size timeStepsPerYear=365, Size nBins=201, Size calibrationPaths=(1 << 15), DateVector mandatoryDates=std::vector< Date >(), Real mixingFactor=1.0) -> HestonSLVMCModel"""
        _QuantLib.HestonSLVMCModel_swiginit(self, _QuantLib.new_HestonSLVMCModel(*args))

    def hestonProcess(self):
        r"""hestonProcess(HestonSLVMCModel self) -> ext::shared_ptr< HestonProcess >"""
        return _QuantLib.HestonSLVMCModel_hestonProcess(self)

    def localVol(self):
        r"""localVol(HestonSLVMCModel self) -> ext::shared_ptr< LocalVolTermStructure >"""
        return _QuantLib.HestonSLVMCModel_localVol(self)

    def leverageFunction(self):
        r"""leverageFunction(HestonSLVMCModel self) -> ext::shared_ptr< LocalVolTermStructure >"""
        return _QuantLib.HestonSLVMCModel_leverageFunction(self)
    __swig_destroy__ = _QuantLib.delete_HestonSLVMCModel

# Register HestonSLVMCModel in _QuantLib:
_QuantLib.HestonSLVMCModel_swigregister(HestonSLVMCModel)
class FdmHestonGreensFct(object):
    r"""Proxy of C++ FdmHestonGreensFct class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    ZeroCorrelation = _QuantLib.FdmHestonGreensFct_ZeroCorrelation
    
    Gaussian = _QuantLib.FdmHestonGreensFct_Gaussian
    
    SemiAnalytical = _QuantLib.FdmHestonGreensFct_SemiAnalytical
    
    __swig_destroy__ = _QuantLib.delete_FdmHestonGreensFct

# Register FdmHestonGreensFct in _QuantLib:
_QuantLib.FdmHestonGreensFct_swigregister(FdmHestonGreensFct)
class HestonSLVFokkerPlanckFdmParams(object):
    r"""Proxy of C++ HestonSLVFokkerPlanckFdmParams class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, xGrid, vGrid, tMaxStepsPerYear, tMinStepsPerYear, tStepNumberDecay, nRannacherTimeSteps, predictionCorretionSteps, x0Density, localVolEpsProb, maxIntegrationIterations, vLowerEps, vUpperEps, vMin, v0Density, vLowerBoundDensity, vUpperBoundDensity, leverageFctPropEps, greensAlgorithm, trafoType, schemeDesc):
        r"""__init__(HestonSLVFokkerPlanckFdmParams self, Size xGrid, Size vGrid, Size tMaxStepsPerYear, Size tMinStepsPerYear, Real tStepNumberDecay, Size nRannacherTimeSteps, Size predictionCorretionSteps, Real x0Density, Real localVolEpsProb, Size maxIntegrationIterations, Real vLowerEps, Real vUpperEps, Real vMin, Real v0Density, Real vLowerBoundDensity, Real vUpperBoundDensity, Real leverageFctPropEps, FdmHestonGreensFct::Algorithm greensAlgorithm, FdmSquareRootFwdOp::TransformationType trafoType, FdmSchemeDesc schemeDesc) -> HestonSLVFokkerPlanckFdmParams"""
        _QuantLib.HestonSLVFokkerPlanckFdmParams_swiginit(self, _QuantLib.new_HestonSLVFokkerPlanckFdmParams(xGrid, vGrid, tMaxStepsPerYear, tMinStepsPerYear, tStepNumberDecay, nRannacherTimeSteps, predictionCorretionSteps, x0Density, localVolEpsProb, maxIntegrationIterations, vLowerEps, vUpperEps, vMin, v0Density, vLowerBoundDensity, vUpperBoundDensity, leverageFctPropEps, greensAlgorithm, trafoType, schemeDesc))
    __swig_destroy__ = _QuantLib.delete_HestonSLVFokkerPlanckFdmParams

# Register HestonSLVFokkerPlanckFdmParams in _QuantLib:
_QuantLib.HestonSLVFokkerPlanckFdmParams_swigregister(HestonSLVFokkerPlanckFdmParams)
class HestonSLVFDMModel(object):
    r"""Proxy of C++ HestonSLVFDMModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(HestonSLVFDMModel self, ext::shared_ptr< LocalVolTermStructure > const & localVol, ext::shared_ptr< HestonModel > const & model, Date endDate, HestonSLVFokkerPlanckFdmParams params, bool const logging=False, DateVector mandatoryDates=std::vector< Date >(), Real mixingFactor=1.0) -> HestonSLVFDMModel"""
        _QuantLib.HestonSLVFDMModel_swiginit(self, _QuantLib.new_HestonSLVFDMModel(*args))

    def hestonProcess(self):
        r"""hestonProcess(HestonSLVFDMModel self) -> ext::shared_ptr< HestonProcess >"""
        return _QuantLib.HestonSLVFDMModel_hestonProcess(self)

    def localVol(self):
        r"""localVol(HestonSLVFDMModel self) -> ext::shared_ptr< LocalVolTermStructure >"""
        return _QuantLib.HestonSLVFDMModel_localVol(self)

    def leverageFunction(self):
        r"""leverageFunction(HestonSLVFDMModel self) -> ext::shared_ptr< LocalVolTermStructure >"""
        return _QuantLib.HestonSLVFDMModel_leverageFunction(self)
    __swig_destroy__ = _QuantLib.delete_HestonSLVFDMModel

# Register HestonSLVFDMModel in _QuantLib:
_QuantLib.HestonSLVFDMModel_swigregister(HestonSLVFDMModel)
class SpreadOption(MultiAssetOption):
    r"""Proxy of C++ SpreadOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        r"""__init__(SpreadOption self, ext::shared_ptr< PlainVanillaPayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> SpreadOption"""
        _QuantLib.SpreadOption_swiginit(self, _QuantLib.new_SpreadOption(payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_SpreadOption

# Register SpreadOption in _QuantLib:
_QuantLib.SpreadOption_swigregister(SpreadOption)
class KirkSpreadOptionEngine(PricingEngine):
    r"""Proxy of C++ KirkSpreadOptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process1, process2, correlation):
        r"""__init__(KirkSpreadOptionEngine self, ext::shared_ptr< BlackProcess > const & process1, ext::shared_ptr< BlackProcess > const & process2, QuoteHandle correlation) -> KirkSpreadOptionEngine"""
        _QuantLib.KirkSpreadOptionEngine_swiginit(self, _QuantLib.new_KirkSpreadOptionEngine(process1, process2, correlation))
    __swig_destroy__ = _QuantLib.delete_KirkSpreadOptionEngine

# Register KirkSpreadOptionEngine in _QuantLib:
_QuantLib.KirkSpreadOptionEngine_swigregister(KirkSpreadOptionEngine)
class Statistics(object):
    r"""Proxy of C++ Statistics class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def samples(self):
        r"""samples(Statistics self) -> Size"""
        return _QuantLib.Statistics_samples(self)

    def weightSum(self):
        r"""weightSum(Statistics self) -> Real"""
        return _QuantLib.Statistics_weightSum(self)

    def mean(self):
        r"""mean(Statistics self) -> Real"""
        return _QuantLib.Statistics_mean(self)

    def variance(self):
        r"""variance(Statistics self) -> Real"""
        return _QuantLib.Statistics_variance(self)

    def standardDeviation(self):
        r"""standardDeviation(Statistics self) -> Real"""
        return _QuantLib.Statistics_standardDeviation(self)

    def errorEstimate(self):
        r"""errorEstimate(Statistics self) -> Real"""
        return _QuantLib.Statistics_errorEstimate(self)

    def skewness(self):
        r"""skewness(Statistics self) -> Real"""
        return _QuantLib.Statistics_skewness(self)

    def kurtosis(self):
        r"""kurtosis(Statistics self) -> Real"""
        return _QuantLib.Statistics_kurtosis(self)

    def min(self):
        r"""min(Statistics self) -> Real"""
        return _QuantLib.Statistics_min(self)

    def max(self):
        r"""max(Statistics self) -> Real"""
        return _QuantLib.Statistics_max(self)

    def reset(self):
        r"""reset(Statistics self)"""
        return _QuantLib.Statistics_reset(self)

    def add(self, *args):
        r"""
        add(Statistics self, Real value, Real weight=1.0)
        add(Statistics self, DoubleVector values)
        add(Statistics self, DoubleVector values, DoubleVector weights)
        """
        return _QuantLib.Statistics_add(self, *args)

    def __init__(self):
        r"""__init__(Statistics self) -> Statistics"""
        _QuantLib.Statistics_swiginit(self, _QuantLib.new_Statistics())
    __swig_destroy__ = _QuantLib.delete_Statistics

# Register Statistics in _QuantLib:
_QuantLib.Statistics_swigregister(Statistics)
class IncrementalStatistics(object):
    r"""Proxy of C++ IncrementalStatistics class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def samples(self):
        r"""samples(IncrementalStatistics self) -> Size"""
        return _QuantLib.IncrementalStatistics_samples(self)

    def weightSum(self):
        r"""weightSum(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_weightSum(self)

    def mean(self):
        r"""mean(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_mean(self)

    def variance(self):
        r"""variance(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_variance(self)

    def standardDeviation(self):
        r"""standardDeviation(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_standardDeviation(self)

    def errorEstimate(self):
        r"""errorEstimate(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_errorEstimate(self)

    def skewness(self):
        r"""skewness(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_skewness(self)

    def kurtosis(self):
        r"""kurtosis(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_kurtosis(self)

    def min(self):
        r"""min(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_min(self)

    def max(self):
        r"""max(IncrementalStatistics self) -> Real"""
        return _QuantLib.IncrementalStatistics_max(self)

    def reset(self):
        r"""reset(IncrementalStatistics self)"""
        return _QuantLib.IncrementalStatistics_reset(self)

    def add(self, *args):
        r"""
        add(IncrementalStatistics self, Real value, Real weight=1.0)
        add(IncrementalStatistics self, DoubleVector values)
        add(IncrementalStatistics self, DoubleVector values, DoubleVector weights)
        """
        return _QuantLib.IncrementalStatistics_add(self, *args)

    def __init__(self):
        r"""__init__(IncrementalStatistics self) -> IncrementalStatistics"""
        _QuantLib.IncrementalStatistics_swiginit(self, _QuantLib.new_IncrementalStatistics())
    __swig_destroy__ = _QuantLib.delete_IncrementalStatistics

# Register IncrementalStatistics in _QuantLib:
_QuantLib.IncrementalStatistics_swigregister(IncrementalStatistics)
class RiskStatistics(Statistics):
    r"""Proxy of C++ RiskStatistics class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def semiVariance(self):
        r"""semiVariance(RiskStatistics self) -> Real"""
        return _QuantLib.RiskStatistics_semiVariance(self)

    def semiDeviation(self):
        r"""semiDeviation(RiskStatistics self) -> Real"""
        return _QuantLib.RiskStatistics_semiDeviation(self)

    def downsideVariance(self):
        r"""downsideVariance(RiskStatistics self) -> Real"""
        return _QuantLib.RiskStatistics_downsideVariance(self)

    def downsideDeviation(self):
        r"""downsideDeviation(RiskStatistics self) -> Real"""
        return _QuantLib.RiskStatistics_downsideDeviation(self)

    def regret(self, target):
        r"""regret(RiskStatistics self, Real target) -> Real"""
        return _QuantLib.RiskStatistics_regret(self, target)

    def potentialUpside(self, percentile):
        r"""potentialUpside(RiskStatistics self, Real percentile) -> Real"""
        return _QuantLib.RiskStatistics_potentialUpside(self, percentile)

    def valueAtRisk(self, percentile):
        r"""valueAtRisk(RiskStatistics self, Real percentile) -> Real"""
        return _QuantLib.RiskStatistics_valueAtRisk(self, percentile)

    def expectedShortfall(self, percentile):
        r"""expectedShortfall(RiskStatistics self, Real percentile) -> Real"""
        return _QuantLib.RiskStatistics_expectedShortfall(self, percentile)

    def shortfall(self, target):
        r"""shortfall(RiskStatistics self, Real target) -> Real"""
        return _QuantLib.RiskStatistics_shortfall(self, target)

    def averageShortfall(self, target):
        r"""averageShortfall(RiskStatistics self, Real target) -> Real"""
        return _QuantLib.RiskStatistics_averageShortfall(self, target)

    def __init__(self):
        r"""__init__(RiskStatistics self) -> RiskStatistics"""
        _QuantLib.RiskStatistics_swiginit(self, _QuantLib.new_RiskStatistics())
    __swig_destroy__ = _QuantLib.delete_RiskStatistics

# Register RiskStatistics in _QuantLib:
_QuantLib.RiskStatistics_swigregister(RiskStatistics)
class MultipleStatistics(object):
    r"""Proxy of C++ GenericSequenceStatistics< Statistics > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimension):
        r"""__init__(MultipleStatistics self, Size dimension) -> MultipleStatistics"""
        _QuantLib.MultipleStatistics_swiginit(self, _QuantLib.new_MultipleStatistics(dimension))

    def size(self):
        r"""size(MultipleStatistics self) -> Size"""
        return _QuantLib.MultipleStatistics_size(self)

    def samples(self):
        r"""samples(MultipleStatistics self) -> Size"""
        return _QuantLib.MultipleStatistics_samples(self)

    def weightSum(self):
        r"""weightSum(MultipleStatistics self) -> Real"""
        return _QuantLib.MultipleStatistics_weightSum(self)

    def mean(self):
        r"""mean(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_mean(self)

    def variance(self):
        r"""variance(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_variance(self)

    def standardDeviation(self):
        r"""standardDeviation(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_standardDeviation(self)

    def errorEstimate(self):
        r"""errorEstimate(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_errorEstimate(self)

    def skewness(self):
        r"""skewness(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_skewness(self)

    def kurtosis(self):
        r"""kurtosis(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_kurtosis(self)

    def min(self):
        r"""min(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_min(self)

    def max(self):
        r"""max(MultipleStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleStatistics_max(self)

    def covariance(self):
        r"""covariance(MultipleStatistics self) -> Matrix"""
        return _QuantLib.MultipleStatistics_covariance(self)

    def correlation(self):
        r"""correlation(MultipleStatistics self) -> Matrix"""
        return _QuantLib.MultipleStatistics_correlation(self)

    def reset(self):
        r"""reset(MultipleStatistics self)"""
        return _QuantLib.MultipleStatistics_reset(self)

    def add(self, *args):
        r"""
        add(MultipleStatistics self, DoubleVector value, Real weight=1.0)
        add(MultipleStatistics self, Array value, Real weight=1.0)
        """
        return _QuantLib.MultipleStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_MultipleStatistics

# Register MultipleStatistics in _QuantLib:
_QuantLib.MultipleStatistics_swigregister(MultipleStatistics)
class SequenceStatistics(object):
    r"""Proxy of C++ GenericSequenceStatistics< RiskStatistics > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimension):
        r"""__init__(SequenceStatistics self, Size dimension) -> SequenceStatistics"""
        _QuantLib.SequenceStatistics_swiginit(self, _QuantLib.new_SequenceStatistics(dimension))

    def size(self):
        r"""size(SequenceStatistics self) -> Size"""
        return _QuantLib.SequenceStatistics_size(self)

    def samples(self):
        r"""samples(SequenceStatistics self) -> Size"""
        return _QuantLib.SequenceStatistics_samples(self)

    def weightSum(self):
        r"""weightSum(SequenceStatistics self) -> Real"""
        return _QuantLib.SequenceStatistics_weightSum(self)

    def mean(self):
        r"""mean(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_mean(self)

    def variance(self):
        r"""variance(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_variance(self)

    def standardDeviation(self):
        r"""standardDeviation(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_standardDeviation(self)

    def errorEstimate(self):
        r"""errorEstimate(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_errorEstimate(self)

    def skewness(self):
        r"""skewness(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_skewness(self)

    def kurtosis(self):
        r"""kurtosis(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_kurtosis(self)

    def min(self):
        r"""min(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_min(self)

    def max(self):
        r"""max(SequenceStatistics self) -> DoubleVector"""
        return _QuantLib.SequenceStatistics_max(self)

    def covariance(self):
        r"""covariance(SequenceStatistics self) -> Matrix"""
        return _QuantLib.SequenceStatistics_covariance(self)

    def correlation(self):
        r"""correlation(SequenceStatistics self) -> Matrix"""
        return _QuantLib.SequenceStatistics_correlation(self)

    def reset(self):
        r"""reset(SequenceStatistics self)"""
        return _QuantLib.SequenceStatistics_reset(self)

    def add(self, *args):
        r"""
        add(SequenceStatistics self, DoubleVector value, Real weight=1.0)
        add(SequenceStatistics self, Array value, Real weight=1.0)
        """
        return _QuantLib.SequenceStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_SequenceStatistics

# Register SequenceStatistics in _QuantLib:
_QuantLib.SequenceStatistics_swigregister(SequenceStatistics)
class MultipleIncrementalStatistics(object):
    r"""Proxy of C++ GenericSequenceStatistics< IncrementalStatistics > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimension):
        r"""__init__(MultipleIncrementalStatistics self, Size dimension) -> MultipleIncrementalStatistics"""
        _QuantLib.MultipleIncrementalStatistics_swiginit(self, _QuantLib.new_MultipleIncrementalStatistics(dimension))

    def size(self):
        r"""size(MultipleIncrementalStatistics self) -> Size"""
        return _QuantLib.MultipleIncrementalStatistics_size(self)

    def samples(self):
        r"""samples(MultipleIncrementalStatistics self) -> Size"""
        return _QuantLib.MultipleIncrementalStatistics_samples(self)

    def weightSum(self):
        r"""weightSum(MultipleIncrementalStatistics self) -> Real"""
        return _QuantLib.MultipleIncrementalStatistics_weightSum(self)

    def mean(self):
        r"""mean(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_mean(self)

    def variance(self):
        r"""variance(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_variance(self)

    def standardDeviation(self):
        r"""standardDeviation(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_standardDeviation(self)

    def errorEstimate(self):
        r"""errorEstimate(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_errorEstimate(self)

    def skewness(self):
        r"""skewness(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_skewness(self)

    def kurtosis(self):
        r"""kurtosis(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_kurtosis(self)

    def min(self):
        r"""min(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_min(self)

    def max(self):
        r"""max(MultipleIncrementalStatistics self) -> DoubleVector"""
        return _QuantLib.MultipleIncrementalStatistics_max(self)

    def covariance(self):
        r"""covariance(MultipleIncrementalStatistics self) -> Matrix"""
        return _QuantLib.MultipleIncrementalStatistics_covariance(self)

    def correlation(self):
        r"""correlation(MultipleIncrementalStatistics self) -> Matrix"""
        return _QuantLib.MultipleIncrementalStatistics_correlation(self)

    def reset(self):
        r"""reset(MultipleIncrementalStatistics self)"""
        return _QuantLib.MultipleIncrementalStatistics_reset(self)

    def add(self, *args):
        r"""
        add(MultipleIncrementalStatistics self, DoubleVector value, Real weight=1.0)
        add(MultipleIncrementalStatistics self, Array value, Real weight=1.0)
        """
        return _QuantLib.MultipleIncrementalStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_MultipleIncrementalStatistics

# Register MultipleIncrementalStatistics in _QuantLib:
_QuantLib.MultipleIncrementalStatistics_swigregister(MultipleIncrementalStatistics)
class CapFloorTermVolatilityStructure(VolatilityTermStructure):
    r"""Proxy of C++ CapFloorTermVolatilityStructure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def volatility(self, *args):
        r"""
        volatility(CapFloorTermVolatilityStructure self, Period length, Rate strike, bool extrapolate=False) -> Volatility
        volatility(CapFloorTermVolatilityStructure self, Date end, Rate strike, bool extrapolate=False) -> Volatility
        volatility(CapFloorTermVolatilityStructure self, Time end, Rate strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.CapFloorTermVolatilityStructure_volatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructure

# Register CapFloorTermVolatilityStructure in _QuantLib:
_QuantLib.CapFloorTermVolatilityStructure_swigregister(CapFloorTermVolatilityStructure)
class CapFloorTermVolatilityStructureHandle(object):
    r"""Proxy of C++ Handle< CapFloorTermVolatilityStructure > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(CapFloorTermVolatilityStructureHandle self, ext::shared_ptr< CapFloorTermVolatilityStructure > const & arg2=ext::shared_ptr()) -> CapFloorTermVolatilityStructureHandle"""
        _QuantLib.CapFloorTermVolatilityStructureHandle_swiginit(self, _QuantLib.new_CapFloorTermVolatilityStructureHandle(*args))

    def __deref__(self):
        r"""__deref__(CapFloorTermVolatilityStructureHandle self) -> ext::shared_ptr< CapFloorTermVolatilityStructure >"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle___deref__(self)

    def currentLink(self):
        r"""currentLink(CapFloorTermVolatilityStructureHandle self) -> ext::shared_ptr< CapFloorTermVolatilityStructure >"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_currentLink(self)

    def __nonzero__(self):
        r"""__nonzero__(CapFloorTermVolatilityStructureHandle self) -> bool"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CapFloorTermVolatilityStructureHandle self) -> bool"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle___bool__(self)

    def asObservable(self):
        r"""asObservable(CapFloorTermVolatilityStructureHandle self) -> ext::shared_ptr< Observable >"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructureHandle

    def volatility(self, *args):
        r"""
        volatility(CapFloorTermVolatilityStructureHandle self, Period length, Rate strike, bool extrapolate=False) -> Volatility
        volatility(CapFloorTermVolatilityStructureHandle self, Date end, Rate strike, bool extrapolate=False) -> Volatility
        volatility(CapFloorTermVolatilityStructureHandle self, Time end, Rate strike, bool extrapolate=False) -> Volatility
        """
        return _QuantLib.CapFloorTermVolatilityStructureHandle_volatility(self, *args)

    def minStrike(self):
        r"""minStrike(CapFloorTermVolatilityStructureHandle self) -> Real"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(CapFloorTermVolatilityStructureHandle self) -> Real"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_maxStrike(self)

    def dayCounter(self):
        r"""dayCounter(CapFloorTermVolatilityStructureHandle self) -> DayCounter"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        r"""timeFromReference(CapFloorTermVolatilityStructureHandle self, Date date) -> Time"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_timeFromReference(self, date)

    def calendar(self):
        r"""calendar(CapFloorTermVolatilityStructureHandle self) -> Calendar"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_calendar(self)

    def referenceDate(self):
        r"""referenceDate(CapFloorTermVolatilityStructureHandle self) -> Date"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_referenceDate(self)

    def maxDate(self):
        r"""maxDate(CapFloorTermVolatilityStructureHandle self) -> Date"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        r"""maxTime(CapFloorTermVolatilityStructureHandle self) -> Time"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        r"""enableExtrapolation(CapFloorTermVolatilityStructureHandle self)"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        r"""disableExtrapolation(CapFloorTermVolatilityStructureHandle self)"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        r"""allowsExtrapolation(CapFloorTermVolatilityStructureHandle self) -> bool"""
        return _QuantLib.CapFloorTermVolatilityStructureHandle_allowsExtrapolation(self)

# Register CapFloorTermVolatilityStructureHandle in _QuantLib:
_QuantLib.CapFloorTermVolatilityStructureHandle_swigregister(CapFloorTermVolatilityStructureHandle)
class RelinkableCapFloorTermVolatilityStructureHandle(CapFloorTermVolatilityStructureHandle):
    r"""Proxy of C++ RelinkableHandle< CapFloorTermVolatilityStructure > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(RelinkableCapFloorTermVolatilityStructureHandle self, ext::shared_ptr< CapFloorTermVolatilityStructure > const & arg2=ext::shared_ptr()) -> RelinkableCapFloorTermVolatilityStructureHandle"""
        _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_swiginit(self, _QuantLib.new_RelinkableCapFloorTermVolatilityStructureHandle(*args))

    def linkTo(self, arg2):
        r"""linkTo(RelinkableCapFloorTermVolatilityStructureHandle self, ext::shared_ptr< CapFloorTermVolatilityStructure > const & arg2)"""
        return _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_linkTo(self, arg2)

    def reset(self):
        r"""reset(RelinkableCapFloorTermVolatilityStructureHandle self)"""
        return _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableCapFloorTermVolatilityStructureHandle

# Register RelinkableCapFloorTermVolatilityStructureHandle in _QuantLib:
_QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_swigregister(RelinkableCapFloorTermVolatilityStructureHandle)
class CapFloorTermVolCurve(CapFloorTermVolatilityStructure):
    r"""Proxy of C++ CapFloorTermVolCurve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CapFloorTermVolCurve self, Date referenceDate, Calendar calendar, BusinessDayConvention bdc, PeriodVector lengths, DoubleVector vols, DayCounter dc=QuantLib::Actual365Fixed()) -> CapFloorTermVolCurve
        __init__(CapFloorTermVolCurve self, Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, PeriodVector lengths, DoubleVector vols, DayCounter dc=QuantLib::Actual365Fixed()) -> CapFloorTermVolCurve
        """
        _QuantLib.CapFloorTermVolCurve_swiginit(self, _QuantLib.new_CapFloorTermVolCurve(*args))
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolCurve

# Register CapFloorTermVolCurve in _QuantLib:
_QuantLib.CapFloorTermVolCurve_swigregister(CapFloorTermVolCurve)
class CapFloorTermVolSurface(CapFloorTermVolatilityStructure):
    r"""Proxy of C++ CapFloorTermVolSurface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CapFloorTermVolSurface self, Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, QuoteHandleVectorVector quotes, DayCounter dc=QuantLib::Actual365Fixed()) -> CapFloorTermVolSurface
        __init__(CapFloorTermVolSurface self, Date settlementDate, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, QuoteHandleVectorVector quotes, DayCounter dc=QuantLib::Actual365Fixed()) -> CapFloorTermVolSurface
        __init__(CapFloorTermVolSurface self, Date settlementDate, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, Matrix volatilities, DayCounter dc=QuantLib::Actual365Fixed()) -> CapFloorTermVolSurface
        __init__(CapFloorTermVolSurface self, Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, Matrix volatilities, DayCounter dc=QuantLib::Actual365Fixed()) -> CapFloorTermVolSurface
        """
        _QuantLib.CapFloorTermVolSurface_swiginit(self, _QuantLib.new_CapFloorTermVolSurface(*args))

    def maxDate(self):
        r"""maxDate(CapFloorTermVolSurface self) -> Date"""
        return _QuantLib.CapFloorTermVolSurface_maxDate(self)

    def minStrike(self):
        r"""minStrike(CapFloorTermVolSurface self) -> Real"""
        return _QuantLib.CapFloorTermVolSurface_minStrike(self)

    def maxStrike(self):
        r"""maxStrike(CapFloorTermVolSurface self) -> Real"""
        return _QuantLib.CapFloorTermVolSurface_maxStrike(self)

    def optionTenors(self):
        r"""optionTenors(CapFloorTermVolSurface self) -> PeriodVector"""
        return _QuantLib.CapFloorTermVolSurface_optionTenors(self)

    def optionDates(self):
        r"""optionDates(CapFloorTermVolSurface self) -> DateVector"""
        return _QuantLib.CapFloorTermVolSurface_optionDates(self)

    def optionTimes(self):
        r"""optionTimes(CapFloorTermVolSurface self) -> DoubleVector"""
        return _QuantLib.CapFloorTermVolSurface_optionTimes(self)

    def strikes(self):
        r"""strikes(CapFloorTermVolSurface self) -> DoubleVector"""
        return _QuantLib.CapFloorTermVolSurface_strikes(self)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolSurface

# Register CapFloorTermVolSurface in _QuantLib:
_QuantLib.CapFloorTermVolSurface_swigregister(CapFloorTermVolSurface)
class StrippedOptionletBase(object):
    r"""Proxy of C++ StrippedOptionletBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def optionletStrikes(self, i):
        r"""optionletStrikes(StrippedOptionletBase self, Size i) -> DoubleVector"""
        return _QuantLib.StrippedOptionletBase_optionletStrikes(self, i)

    def optionletVolatilities(self, i):
        r"""optionletVolatilities(StrippedOptionletBase self, Size i) -> DoubleVector"""
        return _QuantLib.StrippedOptionletBase_optionletVolatilities(self, i)

    def optionletFixingDates(self):
        r"""optionletFixingDates(StrippedOptionletBase self) -> DateVector"""
        return _QuantLib.StrippedOptionletBase_optionletFixingDates(self)

    def optionletFixingTimes(self):
        r"""optionletFixingTimes(StrippedOptionletBase self) -> DoubleVector"""
        return _QuantLib.StrippedOptionletBase_optionletFixingTimes(self)

    def optionletMaturities(self):
        r"""optionletMaturities(StrippedOptionletBase self) -> Size"""
        return _QuantLib.StrippedOptionletBase_optionletMaturities(self)

    def atmOptionletRates(self):
        r"""atmOptionletRates(StrippedOptionletBase self) -> DoubleVector"""
        return _QuantLib.StrippedOptionletBase_atmOptionletRates(self)

    def dayCounter(self):
        r"""dayCounter(StrippedOptionletBase self) -> DayCounter"""
        return _QuantLib.StrippedOptionletBase_dayCounter(self)

    def calendar(self):
        r"""calendar(StrippedOptionletBase self) -> Calendar"""
        return _QuantLib.StrippedOptionletBase_calendar(self)

    def settlementDays(self):
        r"""settlementDays(StrippedOptionletBase self) -> Natural"""
        return _QuantLib.StrippedOptionletBase_settlementDays(self)

    def businessDayConvention(self):
        r"""businessDayConvention(StrippedOptionletBase self) -> BusinessDayConvention"""
        return _QuantLib.StrippedOptionletBase_businessDayConvention(self)

    def volatilityType(self):
        r"""volatilityType(StrippedOptionletBase self) -> VolatilityType"""
        return _QuantLib.StrippedOptionletBase_volatilityType(self)

    def displacement(self):
        r"""displacement(StrippedOptionletBase self) -> Real"""
        return _QuantLib.StrippedOptionletBase_displacement(self)
    __swig_destroy__ = _QuantLib.delete_StrippedOptionletBase

# Register StrippedOptionletBase in _QuantLib:
_QuantLib.StrippedOptionletBase_swigregister(StrippedOptionletBase)
class StrippedOptionlet(StrippedOptionletBase):
    r"""Proxy of C++ StrippedOptionlet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, settlementDays, calendar, bdc, iborIndex, optionletDates, strikes, volatilities, dc, type=ShiftedLognormal, displacement=0.0):
        r"""__init__(StrippedOptionlet self, Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, ext::shared_ptr< IborIndex > iborIndex, DateVector optionletDates, DoubleVector strikes, QuoteHandleVectorVector volatilities, DayCounter dc, VolatilityType type=ShiftedLognormal, Real displacement=0.0) -> StrippedOptionlet"""
        _QuantLib.StrippedOptionlet_swiginit(self, _QuantLib.new_StrippedOptionlet(settlementDays, calendar, bdc, iborIndex, optionletDates, strikes, volatilities, dc, type, displacement))
    __swig_destroy__ = _QuantLib.delete_StrippedOptionlet

# Register StrippedOptionlet in _QuantLib:
_QuantLib.StrippedOptionlet_swigregister(StrippedOptionlet)
class OptionletStripper1(StrippedOptionletBase):
    r"""Proxy of C++ OptionletStripper1 class."""

    thisown = 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):
        r"""__init__(OptionletStripper1 self, ext::shared_ptr< CapFloorTermVolSurface > const & parVolSurface, ext::shared_ptr< IborIndex > const & index, Rate switchStrikes=Null< Rate >(), Real accuracy=1.0e-6, Natural maxIter=100, YieldTermStructureHandle discount=Handle< YieldTermStructure >(), VolatilityType type=ShiftedLognormal, Real displacement=0.0, bool dontThrow=False) -> OptionletStripper1"""
        _QuantLib.OptionletStripper1_swiginit(self, _QuantLib.new_OptionletStripper1(*args, **kwargs))

    def capFloorPrices(self):
        r"""capFloorPrices(OptionletStripper1 self) -> Matrix"""
        return _QuantLib.OptionletStripper1_capFloorPrices(self)

    def capFloorVolatilities(self):
        r"""capFloorVolatilities(OptionletStripper1 self) -> Matrix"""
        return _QuantLib.OptionletStripper1_capFloorVolatilities(self)

    def optionletPrices(self):
        r"""optionletPrices(OptionletStripper1 self) -> Matrix"""
        return _QuantLib.OptionletStripper1_optionletPrices(self)

    def switchStrike(self):
        r"""switchStrike(OptionletStripper1 self) -> Rate"""
        return _QuantLib.OptionletStripper1_switchStrike(self)
    __swig_destroy__ = _QuantLib.delete_OptionletStripper1

# Register OptionletStripper1 in _QuantLib:
_QuantLib.OptionletStripper1_swigregister(OptionletStripper1)
class StrippedOptionletAdapter(OptionletVolatilityStructure):
    r"""Proxy of C++ StrippedOptionletAdapter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        r"""__init__(StrippedOptionletAdapter self, ext::shared_ptr< StrippedOptionletBase > const & arg2) -> StrippedOptionletAdapter"""
        _QuantLib.StrippedOptionletAdapter_swiginit(self, _QuantLib.new_StrippedOptionletAdapter(arg2))
    __swig_destroy__ = _QuantLib.delete_StrippedOptionletAdapter

# Register StrippedOptionletAdapter in _QuantLib:
_QuantLib.StrippedOptionletAdapter_swigregister(StrippedOptionletAdapter)
class Settlement(object):
    r"""Proxy of C++ Settlement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Physical = _QuantLib.Settlement_Physical
    
    Cash = _QuantLib.Settlement_Cash
    
    PhysicalOTC = _QuantLib.Settlement_PhysicalOTC
    
    PhysicalCleared = _QuantLib.Settlement_PhysicalCleared
    
    CollateralizedCashPrice = _QuantLib.Settlement_CollateralizedCashPrice
    
    ParYieldCurve = _QuantLib.Settlement_ParYieldCurve
    

    def __init__(self):
        r"""__init__(Settlement self) -> Settlement"""
        _QuantLib.Settlement_swiginit(self, _QuantLib.new_Settlement())
    __swig_destroy__ = _QuantLib.delete_Settlement

# Register Settlement in _QuantLib:
_QuantLib.Settlement_swigregister(Settlement)
class Swaption(Option):
    r"""Proxy of C++ Swaption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(Swaption self, ext::shared_ptr< VanillaSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, Settlement::Type type=Physical, Settlement::Method settlementMethod=PhysicalOTC) -> Swaption"""
        _QuantLib.Swaption_swiginit(self, _QuantLib.new_Swaption(*args))

    def settlementType(self):
        r"""settlementType(Swaption self) -> Settlement::Type"""
        return _QuantLib.Swaption_settlementType(self)

    def settlementMethod(self):
        r"""settlementMethod(Swaption self) -> Settlement::Method"""
        return _QuantLib.Swaption_settlementMethod(self)

    def type(self):
        r"""type(Swaption self) -> VanillaSwap::Type"""
        return _QuantLib.Swaption_type(self)

    def underlyingSwap(self):
        r"""underlyingSwap(Swaption self) -> ext::shared_ptr< VanillaSwap > const &"""
        return _QuantLib.Swaption_underlyingSwap(self)

    def impliedVolatility(self, price, discountCurve, guess, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0, type=ShiftedLognormal, displacement=0.0):
        r"""impliedVolatility(Swaption self, Real price, YieldTermStructureHandle discountCurve, Volatility guess, Real accuracy=1.0e-4, Natural maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0, VolatilityType type=ShiftedLognormal, Real displacement=0.0) -> Volatility"""
        return _QuantLib.Swaption_impliedVolatility(self, price, discountCurve, guess, accuracy, maxEvaluations, minVol, maxVol, type, displacement)

    def vega(self):
        r"""vega(Swaption self) -> Real"""
        return _QuantLib.Swaption_vega(self)

    def delta(self):
        r"""delta(Swaption self) -> Real"""
        return _QuantLib.Swaption_delta(self)

    def annuity(self):
        r"""annuity(Swaption self) -> Real"""
        return _QuantLib.Swaption_annuity(self)
    __swig_destroy__ = _QuantLib.delete_Swaption

# Register Swaption in _QuantLib:
_QuantLib.Swaption_swigregister(Swaption)
class NonstandardSwaption(Instrument):
    r"""Proxy of C++ NonstandardSwaption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NonstandardSwaption self, ext::shared_ptr< NonstandardSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, Settlement::Type type=Physical, Settlement::Method settlementMethod=PhysicalOTC) -> NonstandardSwaption"""
        _QuantLib.NonstandardSwaption_swiginit(self, _QuantLib.new_NonstandardSwaption(*args))

    def underlyingSwap(self):
        r"""underlyingSwap(NonstandardSwaption self) -> ext::shared_ptr< NonstandardSwap > const &"""
        return _QuantLib.NonstandardSwaption_underlyingSwap(self)

    def calibrationBasket(self, swapIndex, swaptionVolatility, typeStr):
        r"""calibrationBasket(NonstandardSwaption self, ext::shared_ptr< SwapIndex > swapIndex, ext::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility, std::string typeStr) -> BlackCalibrationHelperVector"""
        return _QuantLib.NonstandardSwaption_calibrationBasket(self, swapIndex, swaptionVolatility, typeStr)

    def probabilities(self):
        r"""probabilities(NonstandardSwaption self) -> DoubleVector"""
        return _QuantLib.NonstandardSwaption_probabilities(self)
    __swig_destroy__ = _QuantLib.delete_NonstandardSwaption

# Register NonstandardSwaption in _QuantLib:
_QuantLib.NonstandardSwaption_swigregister(NonstandardSwaption)
class FloatFloatSwaption(Instrument):
    r"""Proxy of C++ FloatFloatSwaption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FloatFloatSwaption self, ext::shared_ptr< FloatFloatSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, Settlement::Type delivery=Physical, Settlement::Method settlementMethod=PhysicalOTC) -> FloatFloatSwaption"""
        _QuantLib.FloatFloatSwaption_swiginit(self, _QuantLib.new_FloatFloatSwaption(*args))

    def underlyingSwap(self):
        r"""underlyingSwap(FloatFloatSwaption self) -> ext::shared_ptr< FloatFloatSwap > const &"""
        return _QuantLib.FloatFloatSwaption_underlyingSwap(self)

    def calibrationBasket(self, swapIndex, swaptionVolatility, typeStr):
        r"""calibrationBasket(FloatFloatSwaption self, ext::shared_ptr< SwapIndex > swapIndex, ext::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility, std::string typeStr) -> BlackCalibrationHelperVector"""
        return _QuantLib.FloatFloatSwaption_calibrationBasket(self, swapIndex, swaptionVolatility, typeStr)

    def underlyingValue(self):
        r"""underlyingValue(FloatFloatSwaption self) -> Real"""
        return _QuantLib.FloatFloatSwaption_underlyingValue(self)

    def probabilities(self):
        r"""probabilities(FloatFloatSwaption self) -> DoubleVector"""
        return _QuantLib.FloatFloatSwaption_probabilities(self)
    __swig_destroy__ = _QuantLib.delete_FloatFloatSwaption

# Register FloatFloatSwaption in _QuantLib:
_QuantLib.FloatFloatSwaption_swigregister(FloatFloatSwaption)
class BlackSwaptionEngine(PricingEngine):
    r"""Proxy of C++ BlackSwaptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(BlackSwaptionEngine self, YieldTermStructureHandle discountCurve, QuoteHandle vol, DayCounter dc=Actual365Fixed(), Real displacement=0.0) -> BlackSwaptionEngine
        __init__(BlackSwaptionEngine self, YieldTermStructureHandle discountCurve, SwaptionVolatilityStructureHandle v) -> BlackSwaptionEngine
        """
        _QuantLib.BlackSwaptionEngine_swiginit(self, _QuantLib.new_BlackSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BlackSwaptionEngine

# Register BlackSwaptionEngine in _QuantLib:
_QuantLib.BlackSwaptionEngine_swigregister(BlackSwaptionEngine)
class BachelierSwaptionEngine(PricingEngine):
    r"""Proxy of C++ BachelierSwaptionEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(BachelierSwaptionEngine self, YieldTermStructureHandle discountCurve, QuoteHandle vol, DayCounter dc=Actual365Fixed()) -> BachelierSwaptionEngine
        __init__(BachelierSwaptionEngine self, YieldTermStructureHandle discountCurve, SwaptionVolatilityStructureHandle v) -> BachelierSwaptionEngine
        """
        _QuantLib.BachelierSwaptionEngine_swiginit(self, _QuantLib.new_BachelierSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BachelierSwaptionEngine

# Register BachelierSwaptionEngine in _QuantLib:
_QuantLib.BachelierSwaptionEngine_swigregister(BachelierSwaptionEngine)
class VanillaSwingOption(OneAssetOption):
    r"""Proxy of C++ VanillaSwingOption class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, ex, minExerciseRights, maxExerciseRights):
        r"""__init__(VanillaSwingOption self, ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< SwingExercise > const & ex, Size minExerciseRights, Size maxExerciseRights) -> VanillaSwingOption"""
        _QuantLib.VanillaSwingOption_swiginit(self, _QuantLib.new_VanillaSwingOption(payoff, ex, minExerciseRights, maxExerciseRights))
    __swig_destroy__ = _QuantLib.delete_VanillaSwingOption

# Register VanillaSwingOption in _QuantLib:
_QuantLib.VanillaSwingOption_swigregister(VanillaSwingOption)
class FdSimpleBSSwingEngine(PricingEngine):
    r"""Proxy of C++ FdSimpleBSSwingEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdSimpleBSSwingEngine self, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=50, Size xGrid=100, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas()) -> FdSimpleBSSwingEngine"""
        _QuantLib.FdSimpleBSSwingEngine_swiginit(self, _QuantLib.new_FdSimpleBSSwingEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdSimpleBSSwingEngine

# Register FdSimpleBSSwingEngine in _QuantLib:
_QuantLib.FdSimpleBSSwingEngine_swigregister(FdSimpleBSSwingEngine)
class FdSimpleExtOUJumpSwingEngine(PricingEngine):
    r"""Proxy of C++ FdSimpleExtOUJumpSwingEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FdSimpleExtOUJumpSwingEngine self, ext::shared_ptr< ExtOUWithJumpsProcess > const & process, ext::shared_ptr< YieldTermStructure > const & rTS, Size tGrid=50, Size xGrid=200, Size yGrid=50, DoublePairVector shape=std::vector< std::pair< Time,Real > >(), FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer()) -> FdSimpleExtOUJumpSwingEngine"""
        _QuantLib.FdSimpleExtOUJumpSwingEngine_swiginit(self, _QuantLib.new_FdSimpleExtOUJumpSwingEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdSimpleExtOUJumpSwingEngine

# Register FdSimpleExtOUJumpSwingEngine in _QuantLib:
_QuantLib.FdSimpleExtOUJumpSwingEngine_swigregister(FdSimpleExtOUJumpSwingEngine)

def enableTracing():
    r"""enableTracing()"""
    return _QuantLib.enableTracing()

def disableTracing():
    r"""disableTracing()"""
    return _QuantLib.disableTracing()
class ConstantEstimator(object):
    r"""Proxy of C++ ConstantEstimator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size):
        r"""__init__(ConstantEstimator self, Size size) -> ConstantEstimator"""
        _QuantLib.ConstantEstimator_swiginit(self, _QuantLib.new_ConstantEstimator(size))

    def calculate(self, arg2):
        r"""calculate(ConstantEstimator self, RealTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.ConstantEstimator_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_ConstantEstimator

# Register ConstantEstimator in _QuantLib:
_QuantLib.ConstantEstimator_swigregister(ConstantEstimator)
class ParkinsonSigma(object):
    r"""Proxy of C++ ParkinsonSigma class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        r"""__init__(ParkinsonSigma self, Real yearFraction) -> ParkinsonSigma"""
        _QuantLib.ParkinsonSigma_swiginit(self, _QuantLib.new_ParkinsonSigma(yearFraction))

    def calculate(self, arg2):
        r"""calculate(ParkinsonSigma self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.ParkinsonSigma_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_ParkinsonSigma

# Register ParkinsonSigma in _QuantLib:
_QuantLib.ParkinsonSigma_swigregister(ParkinsonSigma)
class GarmanKlassSigma1(object):
    r"""Proxy of C++ GarmanKlassSigma1 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        r"""__init__(GarmanKlassSigma1 self, Real yearFraction, Real marketOpenFraction) -> GarmanKlassSigma1"""
        _QuantLib.GarmanKlassSigma1_swiginit(self, _QuantLib.new_GarmanKlassSigma1(yearFraction, marketOpenFraction))

    def calculate(self, arg2):
        r"""calculate(GarmanKlassSigma1 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.GarmanKlassSigma1_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma1

# Register GarmanKlassSigma1 in _QuantLib:
_QuantLib.GarmanKlassSigma1_swigregister(GarmanKlassSigma1)
class GarmanKlassSigma3(object):
    r"""Proxy of C++ GarmanKlassSigma3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        r"""__init__(GarmanKlassSigma3 self, Real yearFraction, Real marketOpenFraction) -> GarmanKlassSigma3"""
        _QuantLib.GarmanKlassSigma3_swiginit(self, _QuantLib.new_GarmanKlassSigma3(yearFraction, marketOpenFraction))

    def calculate(self, arg2):
        r"""calculate(GarmanKlassSigma3 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.GarmanKlassSigma3_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma3

# Register GarmanKlassSigma3 in _QuantLib:
_QuantLib.GarmanKlassSigma3_swigregister(GarmanKlassSigma3)
class GarmanKlassSigma4(object):
    r"""Proxy of C++ GarmanKlassSigma4 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        r"""__init__(GarmanKlassSigma4 self, Real yearFraction) -> GarmanKlassSigma4"""
        _QuantLib.GarmanKlassSigma4_swiginit(self, _QuantLib.new_GarmanKlassSigma4(yearFraction))

    def calculate(self, arg2):
        r"""calculate(GarmanKlassSigma4 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.GarmanKlassSigma4_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma4

# Register GarmanKlassSigma4 in _QuantLib:
_QuantLib.GarmanKlassSigma4_swigregister(GarmanKlassSigma4)
class GarmanKlassSigma5(object):
    r"""Proxy of C++ GarmanKlassSigma5 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        r"""__init__(GarmanKlassSigma5 self, Real yearFraction) -> GarmanKlassSigma5"""
        _QuantLib.GarmanKlassSigma5_swiginit(self, _QuantLib.new_GarmanKlassSigma5(yearFraction))

    def calculate(self, arg2):
        r"""calculate(GarmanKlassSigma5 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.GarmanKlassSigma5_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma5

# Register GarmanKlassSigma5 in _QuantLib:
_QuantLib.GarmanKlassSigma5_swigregister(GarmanKlassSigma5)
class GarmanKlassSigma6(object):
    r"""Proxy of C++ GarmanKlassSigma6 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        r"""__init__(GarmanKlassSigma6 self, Real yearFraction, Real marketOpenFraction) -> GarmanKlassSigma6"""
        _QuantLib.GarmanKlassSigma6_swiginit(self, _QuantLib.new_GarmanKlassSigma6(yearFraction, marketOpenFraction))

    def calculate(self, arg2):
        r"""calculate(GarmanKlassSigma6 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"""
        return _QuantLib.GarmanKlassSigma6_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma6

# Register GarmanKlassSigma6 in _QuantLib:
_QuantLib.GarmanKlassSigma6_swigregister(GarmanKlassSigma6)
class ZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< Linear > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), Linear i=Linear(), Compounding compounding=Continuous, Frequency frequency=Annual) -> ZeroCurve"""
        _QuantLib.ZeroCurve_swiginit(self, _QuantLib.new_ZeroCurve(*args))

    def times(self):
        r"""times(ZeroCurve self) -> DoubleVector"""
        return _QuantLib.ZeroCurve_times(self)

    def data(self):
        r"""data(ZeroCurve self) -> DoubleVector"""
        return _QuantLib.ZeroCurve_data(self)

    def dates(self):
        r"""dates(ZeroCurve self) -> DateVector"""
        return _QuantLib.ZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(ZeroCurve self) -> DoubleVector"""
        return _QuantLib.ZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(ZeroCurve self) -> NodeVector"""
        return _QuantLib.ZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ZeroCurve

# Register ZeroCurve in _QuantLib:
_QuantLib.ZeroCurve_swigregister(ZeroCurve)
class LogLinearZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< LogLinear > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(LogLinearZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), LogLinear i=LogLinear(), Compounding compounding=Continuous, Frequency frequency=Annual) -> LogLinearZeroCurve"""
        _QuantLib.LogLinearZeroCurve_swiginit(self, _QuantLib.new_LogLinearZeroCurve(*args))

    def times(self):
        r"""times(LogLinearZeroCurve self) -> DoubleVector"""
        return _QuantLib.LogLinearZeroCurve_times(self)

    def data(self):
        r"""data(LogLinearZeroCurve self) -> DoubleVector"""
        return _QuantLib.LogLinearZeroCurve_data(self)

    def dates(self):
        r"""dates(LogLinearZeroCurve self) -> DateVector"""
        return _QuantLib.LogLinearZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(LogLinearZeroCurve self) -> DoubleVector"""
        return _QuantLib.LogLinearZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(LogLinearZeroCurve self) -> NodeVector"""
        return _QuantLib.LogLinearZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_LogLinearZeroCurve

# Register LogLinearZeroCurve in _QuantLib:
_QuantLib.LogLinearZeroCurve_swigregister(LogLinearZeroCurve)
class CubicZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< Cubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(CubicZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), Cubic i=Cubic(), Compounding compounding=Continuous, Frequency frequency=Annual) -> CubicZeroCurve"""
        _QuantLib.CubicZeroCurve_swiginit(self, _QuantLib.new_CubicZeroCurve(*args))

    def times(self):
        r"""times(CubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.CubicZeroCurve_times(self)

    def data(self):
        r"""data(CubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.CubicZeroCurve_data(self)

    def dates(self):
        r"""dates(CubicZeroCurve self) -> DateVector"""
        return _QuantLib.CubicZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(CubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.CubicZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(CubicZeroCurve self) -> NodeVector"""
        return _QuantLib.CubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_CubicZeroCurve

# Register CubicZeroCurve in _QuantLib:
_QuantLib.CubicZeroCurve_swigregister(CubicZeroCurve)
class NaturalCubicZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< SplineCubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(NaturalCubicZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), SplineCubic i=SplineCubic(), Compounding compounding=Continuous, Frequency frequency=Annual) -> NaturalCubicZeroCurve"""
        _QuantLib.NaturalCubicZeroCurve_swiginit(self, _QuantLib.new_NaturalCubicZeroCurve(*args))

    def times(self):
        r"""times(NaturalCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.NaturalCubicZeroCurve_times(self)

    def data(self):
        r"""data(NaturalCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.NaturalCubicZeroCurve_data(self)

    def dates(self):
        r"""dates(NaturalCubicZeroCurve self) -> DateVector"""
        return _QuantLib.NaturalCubicZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(NaturalCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.NaturalCubicZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(NaturalCubicZeroCurve self) -> NodeVector"""
        return _QuantLib.NaturalCubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_NaturalCubicZeroCurve

# Register NaturalCubicZeroCurve in _QuantLib:
_QuantLib.NaturalCubicZeroCurve_swigregister(NaturalCubicZeroCurve)
class LogCubicZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< DefaultLogCubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(LogCubicZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), DefaultLogCubic i=DefaultLogCubic(), Compounding compounding=Continuous, Frequency frequency=Annual) -> LogCubicZeroCurve"""
        _QuantLib.LogCubicZeroCurve_swiginit(self, _QuantLib.new_LogCubicZeroCurve(*args))

    def times(self):
        r"""times(LogCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.LogCubicZeroCurve_times(self)

    def data(self):
        r"""data(LogCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.LogCubicZeroCurve_data(self)

    def dates(self):
        r"""dates(LogCubicZeroCurve self) -> DateVector"""
        return _QuantLib.LogCubicZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(LogCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.LogCubicZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(LogCubicZeroCurve self) -> NodeVector"""
        return _QuantLib.LogCubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_LogCubicZeroCurve

# Register LogCubicZeroCurve in _QuantLib:
_QuantLib.LogCubicZeroCurve_swigregister(LogCubicZeroCurve)
class MonotonicCubicZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< MonotonicCubic > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(MonotonicCubicZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), MonotonicCubic i=MonotonicCubic(), Compounding compounding=Continuous, Frequency frequency=Annual) -> MonotonicCubicZeroCurve"""
        _QuantLib.MonotonicCubicZeroCurve_swiginit(self, _QuantLib.new_MonotonicCubicZeroCurve(*args))

    def times(self):
        r"""times(MonotonicCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.MonotonicCubicZeroCurve_times(self)

    def data(self):
        r"""data(MonotonicCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.MonotonicCubicZeroCurve_data(self)

    def dates(self):
        r"""dates(MonotonicCubicZeroCurve self) -> DateVector"""
        return _QuantLib.MonotonicCubicZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(MonotonicCubicZeroCurve self) -> DoubleVector"""
        return _QuantLib.MonotonicCubicZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(MonotonicCubicZeroCurve self) -> NodeVector"""
        return _QuantLib.MonotonicCubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicZeroCurve

# Register MonotonicCubicZeroCurve in _QuantLib:
_QuantLib.MonotonicCubicZeroCurve_swigregister(MonotonicCubicZeroCurve)
class KrugerZeroCurve(YieldTermStructure):
    r"""Proxy of C++ InterpolatedZeroCurve< Kruger > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(KrugerZeroCurve self, DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), Kruger i=Kruger(), Compounding compounding=Continuous, Frequency frequency=Annual) -> KrugerZeroCurve"""
        _QuantLib.KrugerZeroCurve_swiginit(self, _QuantLib.new_KrugerZeroCurve(*args))

    def times(self):
        r"""times(KrugerZeroCurve self) -> DoubleVector"""
        return _QuantLib.KrugerZeroCurve_times(self)

    def data(self):
        r"""data(KrugerZeroCurve self) -> DoubleVector"""
        return _QuantLib.KrugerZeroCurve_data(self)

    def dates(self):
        r"""dates(KrugerZeroCurve self) -> DateVector"""
        return _QuantLib.KrugerZeroCurve_dates(self)

    def zeroRates(self):
        r"""zeroRates(KrugerZeroCurve self) -> DoubleVector"""
        return _QuantLib.KrugerZeroCurve_zeroRates(self)

    def nodes(self):
        r"""nodes(KrugerZeroCurve self) -> NodeVector"""
        return _QuantLib.KrugerZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_KrugerZeroCurve

# Register KrugerZeroCurve in _QuantLib:
_QuantLib.KrugerZeroCurve_swigregister(KrugerZeroCurve)