File: QuantLib.py

package info (click to toggle)
quantlib-swig 0.3.13-3
links: PTS
area: main
in suites: etch, etch-m68k
size: 43,120 kB
ctags: 74,378
sloc: cpp: 795,926; ansic: 103,715; ml: 39,516; cs: 24,631; java: 17,063; perl: 12,601; python: 6,752; lisp: 2,223; ruby: 1,103; sh: 458; makefile: 319
file content (6215 lines) | stat: -rw-r--r-- 305,957 bytes
# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.

import _QuantLib
import new
new_instancemethod = new.instancemethod
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


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


class PySwigIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args): return _QuantLib.PySwigIterator_value(*args)
    def incr(*args): return _QuantLib.PySwigIterator_incr(*args)
    def decr(*args): return _QuantLib.PySwigIterator_decr(*args)
    def distance(*args): return _QuantLib.PySwigIterator_distance(*args)
    def equal(*args): return _QuantLib.PySwigIterator_equal(*args)
    def copy(*args): return _QuantLib.PySwigIterator_copy(*args)
    def next(*args): return _QuantLib.PySwigIterator_next(*args)
    def previous(*args): return _QuantLib.PySwigIterator_previous(*args)
    def advance(*args): return _QuantLib.PySwigIterator_advance(*args)
    def __eq__(*args): return _QuantLib.PySwigIterator___eq__(*args)
    def __ne__(*args): return _QuantLib.PySwigIterator___ne__(*args)
    def __iadd__(*args): return _QuantLib.PySwigIterator___iadd__(*args)
    def __isub__(*args): return _QuantLib.PySwigIterator___isub__(*args)
    def __add__(*args): return _QuantLib.PySwigIterator___add__(*args)
    def __sub__(*args): return _QuantLib.PySwigIterator___sub__(*args)
    def __iter__(self): return self
PySwigIterator_swigregister = _QuantLib.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)
cvar = _QuantLib.cvar
__hexversion__ = cvar.__hexversion__
__version__ = cvar.__version__

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

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

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

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

class LexicographicalViewColumn(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def __getitem__(*args): return _QuantLib.LexicographicalViewColumn___getitem__(*args)
    def __setitem__(*args): return _QuantLib.LexicographicalViewColumn___setitem__(*args)
    __swig_destroy__ = _QuantLib.delete_LexicographicalViewColumn
    __del__ = lambda self : None;
LexicographicalViewColumn_swigregister = _QuantLib.LexicographicalViewColumn_swigregister
LexicographicalViewColumn_swigregister(LexicographicalViewColumn)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class CubicSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CubicSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _QuantLib.CubicSpline___call__(*args)
    def derivative(*args): return _QuantLib.CubicSpline_derivative(*args)
    def secondDerivative(*args): return _QuantLib.CubicSpline_secondDerivative(*args)
    __swig_destroy__ = _QuantLib.delete_CubicSpline
    __del__ = lambda self : None;
CubicSpline_swigregister = _QuantLib.CubicSpline_swigregister
CubicSpline_swigregister(CubicSpline)

class MonotonicCubicSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MonotonicCubicSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _QuantLib.MonotonicCubicSpline___call__(*args)
    def derivative(*args): return _QuantLib.MonotonicCubicSpline_derivative(*args)
    def secondDerivative(*args): return _QuantLib.MonotonicCubicSpline_secondDerivative(*args)
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicSpline
    __del__ = lambda self : None;
MonotonicCubicSpline_swigregister = _QuantLib.MonotonicCubicSpline_swigregister
MonotonicCubicSpline_swigregister(MonotonicCubicSpline)

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

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

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

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

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

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

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

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

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

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

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

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

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

class BlackModel(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(*args): return _QuantLib.BlackModel___deref__(*args)
    def __nonzero__(*args): return _QuantLib.BlackModel___nonzero__(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_BlackModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackModel
    __del__ = lambda self : None;
BlackModel_swigregister = _QuantLib.BlackModel_swigregister
BlackModel_swigregister(BlackModel)

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

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

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

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

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

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

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

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

class HistoryEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_HistoryEntry
    __del__ = lambda self : None;
HistoryEntry_swigregister = _QuantLib.HistoryEntry_swigregister
HistoryEntry_swigregister(HistoryEntry)

class HistoryIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def next(*args): return _QuantLib.HistoryIterator_next(*args)
    __swig_destroy__ = _QuantLib.delete_HistoryIterator
    __del__ = lambda self : None;
HistoryIterator_swigregister = _QuantLib.HistoryIterator_swigregister
HistoryIterator_swigregister(HistoryIterator)

class HistoryValidIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def next(*args): return _QuantLib.HistoryValidIterator_next(*args)
    def __iter__(*args): return _QuantLib.HistoryValidIterator___iter__(*args)
    __swig_destroy__ = _QuantLib.delete_HistoryValidIterator
    __del__ = lambda self : None;
HistoryValidIterator_swigregister = _QuantLib.HistoryValidIterator_swigregister
HistoryValidIterator_swigregister(HistoryValidIterator)

class History(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_History(*args)
        try: self.this.append(this)
        except: self.this = this
    def firstDate(*args): return _QuantLib.History_firstDate(*args)
    def lastDate(*args): return _QuantLib.History_lastDate(*args)
    def __len__(*args): return _QuantLib.History___len__(*args)
    def __getitem__(*args): return _QuantLib.History___getitem__(*args)
    def __iter__(*args): return _QuantLib.History___iter__(*args)
    def valid(*args): return _QuantLib.History_valid(*args)
    __swig_destroy__ = _QuantLib.delete_History
    __del__ = lambda self : None;
History_swigregister = _QuantLib.History_swigregister
History_swigregister(History)

History._old___init__ = History.__init__
def History_new___init__(self,dates,values):
    values = values[:]
    for i in range(len(values)):
        if values[i] is None:
            values[i] = nullDouble()
    self._old___init__(dates,values)
History.__init__ = History_new___init__

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

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

class Xibor(Index):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Xibor(*args)
        try: self.this.append(this)
        except: self.this = this
    def tenor(*args): return _QuantLib.Xibor_tenor(*args)
    def frequency(*args): return _QuantLib.Xibor_frequency(*args)
    def currency(*args): return _QuantLib.Xibor_currency(*args)
    def calendar(*args): return _QuantLib.Xibor_calendar(*args)
    def isAdjusted(*args): return _QuantLib.Xibor_isAdjusted(*args)
    def businessDayConvention(*args): return _QuantLib.Xibor_businessDayConvention(*args)
    def dayCounter(*args): return _QuantLib.Xibor_dayCounter(*args)
    __swig_destroy__ = _QuantLib.delete_Xibor
    __del__ = lambda self : None;
Xibor_swigregister = _QuantLib.Xibor_swigregister
Xibor_swigregister(Xibor)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class CapletVolatilityStructure(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(*args): return _QuantLib.CapletVolatilityStructure___deref__(*args)
    def __nonzero__(*args): return _QuantLib.CapletVolatilityStructure___nonzero__(*args)
    def asObservable(*args): return _QuantLib.CapletVolatilityStructure_asObservable(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_CapletVolatilityStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapletVolatilityStructure
    __del__ = lambda self : None;
    def referenceDate(*args): return _QuantLib.CapletVolatilityStructure_referenceDate(*args)
    def dayCounter(*args): return _QuantLib.CapletVolatilityStructure_dayCounter(*args)
    def calendar(*args): return _QuantLib.CapletVolatilityStructure_calendar(*args)
    def maxDate(*args): return _QuantLib.CapletVolatilityStructure_maxDate(*args)
    def maxTime(*args): return _QuantLib.CapletVolatilityStructure_maxTime(*args)
    def minStrike(*args): return _QuantLib.CapletVolatilityStructure_minStrike(*args)
    def maxStrike(*args): return _QuantLib.CapletVolatilityStructure_maxStrike(*args)
    def volatility(*args): return _QuantLib.CapletVolatilityStructure_volatility(*args)
    def enableExtrapolation(*args): return _QuantLib.CapletVolatilityStructure_enableExtrapolation(*args)
    def disableExtrapolation(*args): return _QuantLib.CapletVolatilityStructure_disableExtrapolation(*args)
    def allowsExtrapolation(*args): return _QuantLib.CapletVolatilityStructure_allowsExtrapolation(*args)
CapletVolatilityStructure_swigregister = _QuantLib.CapletVolatilityStructure_swigregister
CapletVolatilityStructure_swigregister(CapletVolatilityStructure)

class CapletVolatilityStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapletVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args): return _QuantLib.CapletVolatilityStructureHandle___deref__(*args)
    def linkTo(*args): return _QuantLib.CapletVolatilityStructureHandle_linkTo(*args)
    def __nonzero__(*args): return _QuantLib.CapletVolatilityStructureHandle___nonzero__(*args)
    def asObservable(*args): return _QuantLib.CapletVolatilityStructureHandle_asObservable(*args)
    __swig_destroy__ = _QuantLib.delete_CapletVolatilityStructureHandle
    __del__ = lambda self : None;
    def referenceDate(*args): return _QuantLib.CapletVolatilityStructureHandle_referenceDate(*args)
    def dayCounter(*args): return _QuantLib.CapletVolatilityStructureHandle_dayCounter(*args)
    def calendar(*args): return _QuantLib.CapletVolatilityStructureHandle_calendar(*args)
    def maxDate(*args): return _QuantLib.CapletVolatilityStructureHandle_maxDate(*args)
    def maxTime(*args): return _QuantLib.CapletVolatilityStructureHandle_maxTime(*args)
    def minStrike(*args): return _QuantLib.CapletVolatilityStructureHandle_minStrike(*args)
    def maxStrike(*args): return _QuantLib.CapletVolatilityStructureHandle_maxStrike(*args)
    def volatility(*args): return _QuantLib.CapletVolatilityStructureHandle_volatility(*args)
    def enableExtrapolation(*args): return _QuantLib.CapletVolatilityStructureHandle_enableExtrapolation(*args)
    def disableExtrapolation(*args): return _QuantLib.CapletVolatilityStructureHandle_disableExtrapolation(*args)
    def allowsExtrapolation(*args): return _QuantLib.CapletVolatilityStructureHandle_allowsExtrapolation(*args)
CapletVolatilityStructureHandle_swigregister = _QuantLib.CapletVolatilityStructureHandle_swigregister
CapletVolatilityStructureHandle_swigregister(CapletVolatilityStructureHandle)

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

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

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

class CapletConstantVolatility(CapletVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapletConstantVolatility(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapletConstantVolatility
    __del__ = lambda self : None;
CapletConstantVolatility_swigregister = _QuantLib.CapletConstantVolatility_swigregister
CapletConstantVolatility_swigregister(CapletConstantVolatility)

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

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

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

class ParCoupon(CashFlow):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ParCoupon(*args)
        try: self.this.append(this)
        except: self.this = this
    def accrualStartDate(*args): return _QuantLib.ParCoupon_accrualStartDate(*args)
    def accrualEndDate(*args): return _QuantLib.ParCoupon_accrualEndDate(*args)
    def rate(*args): return _QuantLib.ParCoupon_rate(*args)
    def indexFixing(*args): return _QuantLib.ParCoupon_indexFixing(*args)
    def nominal(*args): return _QuantLib.ParCoupon_nominal(*args)
    __swig_destroy__ = _QuantLib.delete_ParCoupon
    __del__ = lambda self : None;
ParCoupon_swigregister = _QuantLib.ParCoupon_swigregister
ParCoupon_swigregister(ParCoupon)

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

class IndexedCoupon(FloatingRateCoupon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_IndexedCoupon(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_IndexedCoupon
    __del__ = lambda self : None;
IndexedCoupon_swigregister = _QuantLib.IndexedCoupon_swigregister
IndexedCoupon_swigregister(IndexedCoupon)

class UpFrontIndexedCoupon(IndexedCoupon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_UpFrontIndexedCoupon(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_UpFrontIndexedCoupon
    __del__ = lambda self : None;
UpFrontIndexedCoupon_swigregister = _QuantLib.UpFrontIndexedCoupon_swigregister
UpFrontIndexedCoupon_swigregister(UpFrontIndexedCoupon)

class InArrearIndexedCoupon(IndexedCoupon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InArrearIndexedCoupon(*args)
        try: self.this.append(this)
        except: self.this = this
    def setCapletVolatility(*args): return _QuantLib.InArrearIndexedCoupon_setCapletVolatility(*args)
    __swig_destroy__ = _QuantLib.delete_InArrearIndexedCoupon
    __del__ = lambda self : None;
InArrearIndexedCoupon_swigregister = _QuantLib.InArrearIndexedCoupon_swigregister
InArrearIndexedCoupon_swigregister(InArrearIndexedCoupon)

class CashFlowVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args): return _QuantLib.CashFlowVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _QuantLib.CashFlowVector___nonzero__(*args)
    def __len__(*args): return _QuantLib.CashFlowVector___len__(*args)
    def pop(*args): return _QuantLib.CashFlowVector_pop(*args)
    def __getslice__(*args): return _QuantLib.CashFlowVector___getslice__(*args)
    def __setslice__(*args): return _QuantLib.CashFlowVector___setslice__(*args)
    def __delslice__(*args): return _QuantLib.CashFlowVector___delslice__(*args)
    def __delitem__(*args): return _QuantLib.CashFlowVector___delitem__(*args)
    def __getitem__(*args): return _QuantLib.CashFlowVector___getitem__(*args)
    def __setitem__(*args): return _QuantLib.CashFlowVector___setitem__(*args)
    def append(*args): return _QuantLib.CashFlowVector_append(*args)
    def empty(*args): return _QuantLib.CashFlowVector_empty(*args)
    def size(*args): return _QuantLib.CashFlowVector_size(*args)
    def clear(*args): return _QuantLib.CashFlowVector_clear(*args)
    def swap(*args): return _QuantLib.CashFlowVector_swap(*args)
    def get_allocator(*args): return _QuantLib.CashFlowVector_get_allocator(*args)
    def begin(*args): return _QuantLib.CashFlowVector_begin(*args)
    def end(*args): return _QuantLib.CashFlowVector_end(*args)
    def rbegin(*args): return _QuantLib.CashFlowVector_rbegin(*args)
    def rend(*args): return _QuantLib.CashFlowVector_rend(*args)
    def pop_back(*args): return _QuantLib.CashFlowVector_pop_back(*args)
    def erase(*args): return _QuantLib.CashFlowVector_erase(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_CashFlowVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _QuantLib.CashFlowVector_push_back(*args)
    def front(*args): return _QuantLib.CashFlowVector_front(*args)
    def back(*args): return _QuantLib.CashFlowVector_back(*args)
    def assign(*args): return _QuantLib.CashFlowVector_assign(*args)
    def resize(*args): return _QuantLib.CashFlowVector_resize(*args)
    def insert(*args): return _QuantLib.CashFlowVector_insert(*args)
    def reserve(*args): return _QuantLib.CashFlowVector_reserve(*args)
    def capacity(*args): return _QuantLib.CashFlowVector_capacity(*args)
    __swig_destroy__ = _QuantLib.delete_CashFlowVector
    __del__ = lambda self : None;
CashFlowVector_swigregister = _QuantLib.CashFlowVector_swigregister
CashFlowVector_swigregister(CashFlowVector)

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

class Cashflows(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    npv = staticmethod(_QuantLib.Cashflows_npv)
    irr = staticmethod(_QuantLib.Cashflows_irr)
    duration = staticmethod(_QuantLib.Cashflows_duration)
    convexity = staticmethod(_QuantLib.Cashflows_convexity)
    __swig_destroy__ = _QuantLib.delete_Cashflows
    __del__ = lambda self : None;
Cashflows_swigregister = _QuantLib.Cashflows_swigregister
Cashflows_swigregister(Cashflows)
Cashflows_npv = _QuantLib.Cashflows_npv
Cashflows_irr = _QuantLib.Cashflows_irr
Cashflows_duration = _QuantLib.Cashflows_duration
Cashflows_convexity = _QuantLib.Cashflows_convexity

class Bond(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def settlementDate(*args): return _QuantLib.Bond_settlementDate(*args)
    def cashflows(*args): return _QuantLib.Bond_cashflows(*args)
    def redemption(*args): return _QuantLib.Bond_redemption(*args)
    def calendar(*args): return _QuantLib.Bond_calendar(*args)
    def accrualConvention(*args): return _QuantLib.Bond_accrualConvention(*args)
    def paymentConvention(*args): return _QuantLib.Bond_paymentConvention(*args)
    def dayCounter(*args): return _QuantLib.Bond_dayCounter(*args)
    def frequency(*args): return _QuantLib.Bond_frequency(*args)
    def cleanPrice(*args): return _QuantLib.Bond_cleanPrice(*args)
    def dirtyPrice(*args): return _QuantLib.Bond_dirtyPrice(*args)
    def bondYield(*args): return _QuantLib.Bond_bondYield(*args)
    def accruedAmount(*args): return _QuantLib.Bond_accruedAmount(*args)
    __swig_destroy__ = _QuantLib.delete_Bond
    __del__ = lambda self : None;
Bond_swigregister = _QuantLib.Bond_swigregister
Bond_swigregister(Bond)

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

class FixedCouponBond(Bond):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FixedCouponBond(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FixedCouponBond
    __del__ = lambda self : None;
FixedCouponBond_swigregister = _QuantLib.FixedCouponBond_swigregister
FixedCouponBond_swigregister(FixedCouponBond)

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

class Price(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Dirty = _QuantLib.Price_Dirty
    Clean = _QuantLib.Price_Clean
    def __init__(self, *args): 
        this = _QuantLib.new_Price(*args)
        try: self.this.append(this)
        except: self.this = this
    def amount(*args): return _QuantLib.Price_amount(*args)
    def type(*args): return _QuantLib.Price_type(*args)
    __swig_destroy__ = _QuantLib.delete_Price
    __del__ = lambda self : None;
Price_swigregister = _QuantLib.Price_swigregister
Price_swigregister(Price)

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

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

class CallabilityVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args): return _QuantLib.CallabilityVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _QuantLib.CallabilityVector___nonzero__(*args)
    def __len__(*args): return _QuantLib.CallabilityVector___len__(*args)
    def pop(*args): return _QuantLib.CallabilityVector_pop(*args)
    def __getslice__(*args): return _QuantLib.CallabilityVector___getslice__(*args)
    def __setslice__(*args): return _QuantLib.CallabilityVector___setslice__(*args)
    def __delslice__(*args): return _QuantLib.CallabilityVector___delslice__(*args)
    def __delitem__(*args): return _QuantLib.CallabilityVector___delitem__(*args)
    def __getitem__(*args): return _QuantLib.CallabilityVector___getitem__(*args)
    def __setitem__(*args): return _QuantLib.CallabilityVector___setitem__(*args)
    def append(*args): return _QuantLib.CallabilityVector_append(*args)
    def empty(*args): return _QuantLib.CallabilityVector_empty(*args)
    def size(*args): return _QuantLib.CallabilityVector_size(*args)
    def clear(*args): return _QuantLib.CallabilityVector_clear(*args)
    def swap(*args): return _QuantLib.CallabilityVector_swap(*args)
    def get_allocator(*args): return _QuantLib.CallabilityVector_get_allocator(*args)
    def begin(*args): return _QuantLib.CallabilityVector_begin(*args)
    def end(*args): return _QuantLib.CallabilityVector_end(*args)
    def rbegin(*args): return _QuantLib.CallabilityVector_rbegin(*args)
    def rend(*args): return _QuantLib.CallabilityVector_rend(*args)
    def pop_back(*args): return _QuantLib.CallabilityVector_pop_back(*args)
    def erase(*args): return _QuantLib.CallabilityVector_erase(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_CallabilityVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _QuantLib.CallabilityVector_push_back(*args)
    def front(*args): return _QuantLib.CallabilityVector_front(*args)
    def back(*args): return _QuantLib.CallabilityVector_back(*args)
    def assign(*args): return _QuantLib.CallabilityVector_assign(*args)
    def resize(*args): return _QuantLib.CallabilityVector_resize(*args)
    def insert(*args): return _QuantLib.CallabilityVector_insert(*args)
    def reserve(*args): return _QuantLib.CallabilityVector_reserve(*args)
    def capacity(*args): return _QuantLib.CallabilityVector_capacity(*args)
    __swig_destroy__ = _QuantLib.delete_CallabilityVector
    __del__ = lambda self : None;
CallabilityVector_swigregister = _QuantLib.CallabilityVector_swigregister
CallabilityVector_swigregister(CallabilityVector)

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

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

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

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

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

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

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

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

class StochasticProcess1DVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args): return _QuantLib.StochasticProcess1DVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _QuantLib.StochasticProcess1DVector___nonzero__(*args)
    def __len__(*args): return _QuantLib.StochasticProcess1DVector___len__(*args)
    def pop(*args): return _QuantLib.StochasticProcess1DVector_pop(*args)
    def __getslice__(*args): return _QuantLib.StochasticProcess1DVector___getslice__(*args)
    def __setslice__(*args): return _QuantLib.StochasticProcess1DVector___setslice__(*args)
    def __delslice__(*args): return _QuantLib.StochasticProcess1DVector___delslice__(*args)
    def __delitem__(*args): return _QuantLib.StochasticProcess1DVector___delitem__(*args)
    def __getitem__(*args): return _QuantLib.StochasticProcess1DVector___getitem__(*args)
    def __setitem__(*args): return _QuantLib.StochasticProcess1DVector___setitem__(*args)
    def append(*args): return _QuantLib.StochasticProcess1DVector_append(*args)
    def empty(*args): return _QuantLib.StochasticProcess1DVector_empty(*args)
    def size(*args): return _QuantLib.StochasticProcess1DVector_size(*args)
    def clear(*args): return _QuantLib.StochasticProcess1DVector_clear(*args)
    def swap(*args): return _QuantLib.StochasticProcess1DVector_swap(*args)
    def get_allocator(*args): return _QuantLib.StochasticProcess1DVector_get_allocator(*args)
    def begin(*args): return _QuantLib.StochasticProcess1DVector_begin(*args)
    def end(*args): return _QuantLib.StochasticProcess1DVector_end(*args)
    def rbegin(*args): return _QuantLib.StochasticProcess1DVector_rbegin(*args)
    def rend(*args): return _QuantLib.StochasticProcess1DVector_rend(*args)
    def pop_back(*args): return _QuantLib.StochasticProcess1DVector_pop_back(*args)
    def erase(*args): return _QuantLib.StochasticProcess1DVector_erase(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_StochasticProcess1DVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _QuantLib.StochasticProcess1DVector_push_back(*args)
    def front(*args): return _QuantLib.StochasticProcess1DVector_front(*args)
    def back(*args): return _QuantLib.StochasticProcess1DVector_back(*args)
    def assign(*args): return _QuantLib.StochasticProcess1DVector_assign(*args)
    def resize(*args): return _QuantLib.StochasticProcess1DVector_resize(*args)
    def insert(*args): return _QuantLib.StochasticProcess1DVector_insert(*args)
    def reserve(*args): return _QuantLib.StochasticProcess1DVector_reserve(*args)
    def capacity(*args): return _QuantLib.StochasticProcess1DVector_capacity(*args)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess1DVector
    __del__ = lambda self : None;
StochasticProcess1DVector_swigregister = _QuantLib.StochasticProcess1DVector_swigregister
StochasticProcess1DVector_swigregister(StochasticProcess1DVector)

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

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

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

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

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

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

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

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

class BinomialEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BinomialEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialEuropeanEngine
    __del__ = lambda self : None;
BinomialEuropeanEngine_swigregister = _QuantLib.BinomialEuropeanEngine_swigregister
BinomialEuropeanEngine_swigregister(BinomialEuropeanEngine)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class CompoundForward(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CompoundForward(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(*args): return _QuantLib.CompoundForward_dates(*args)
    def compoundForward(*args): return _QuantLib.CompoundForward_compoundForward(*args)
    __swig_destroy__ = _QuantLib.delete_CompoundForward
    __del__ = lambda self : None;
CompoundForward_swigregister = _QuantLib.CompoundForward_swigregister
CompoundForward_swigregister(CompoundForward)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class TrapezoidIntegral(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TrapezoidIntegral(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _QuantLib.TrapezoidIntegral___call__(*args)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegral
    __del__ = lambda self : None;
TrapezoidIntegral_swigregister = _QuantLib.TrapezoidIntegral_swigregister
TrapezoidIntegral_swigregister(TrapezoidIntegral)

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

class KronrodIntegral(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_KronrodIntegral(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _QuantLib.KronrodIntegral___call__(*args)
    __swig_destroy__ = _QuantLib.delete_KronrodIntegral
    __del__ = lambda self : None;
KronrodIntegral_swigregister = _QuantLib.KronrodIntegral_swigregister
KronrodIntegral_swigregister(KronrodIntegral)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class EndCriteria(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EndCriteria(*args)
        try: self.this.append(this)
        except: self.this = this
    def setPositiveOptimization(*args): return _QuantLib.EndCriteria_setPositiveOptimization(*args)
    def __call__(*args): return _QuantLib.EndCriteria___call__(*args)
    __swig_destroy__ = _QuantLib.delete_EndCriteria
    __del__ = lambda self : None;
EndCriteria_swigregister = _QuantLib.EndCriteria_swigregister
EndCriteria_swigregister(EndCriteria)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class FixedCouponBondHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FixedCouponBondHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FixedCouponBondHelper
    __del__ = lambda self : None;
FixedCouponBondHelper_swigregister = _QuantLib.FixedCouponBondHelper_swigregister
FixedCouponBondHelper_swigregister(FixedCouponBondHelper)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class DiscreteGeometricASO(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DiscreteGeometricASO(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(*args): return _QuantLib.DiscreteGeometricASO_value(*args)
    __swig_destroy__ = _QuantLib.delete_DiscreteGeometricASO
    __del__ = lambda self : None;
DiscreteGeometricASO_swigregister = _QuantLib.DiscreteGeometricASO_swigregister
DiscreteGeometricASO_swigregister(DiscreteGeometricASO)

class YieldTermStructureVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args): return _QuantLib.YieldTermStructureVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _QuantLib.YieldTermStructureVector___nonzero__(*args)
    def __len__(*args): return _QuantLib.YieldTermStructureVector___len__(*args)
    def pop(*args): return _QuantLib.YieldTermStructureVector_pop(*args)
    def __getslice__(*args): return _QuantLib.YieldTermStructureVector___getslice__(*args)
    def __setslice__(*args): return _QuantLib.YieldTermStructureVector___setslice__(*args)
    def __delslice__(*args): return _QuantLib.YieldTermStructureVector___delslice__(*args)
    def __delitem__(*args): return _QuantLib.YieldTermStructureVector___delitem__(*args)
    def __getitem__(*args): return _QuantLib.YieldTermStructureVector___getitem__(*args)
    def __setitem__(*args): return _QuantLib.YieldTermStructureVector___setitem__(*args)
    def append(*args): return _QuantLib.YieldTermStructureVector_append(*args)
    def empty(*args): return _QuantLib.YieldTermStructureVector_empty(*args)
    def size(*args): return _QuantLib.YieldTermStructureVector_size(*args)
    def clear(*args): return _QuantLib.YieldTermStructureVector_clear(*args)
    def swap(*args): return _QuantLib.YieldTermStructureVector_swap(*args)
    def get_allocator(*args): return _QuantLib.YieldTermStructureVector_get_allocator(*args)
    def begin(*args): return _QuantLib.YieldTermStructureVector_begin(*args)
    def end(*args): return _QuantLib.YieldTermStructureVector_end(*args)
    def rbegin(*args): return _QuantLib.YieldTermStructureVector_rbegin(*args)
    def rend(*args): return _QuantLib.YieldTermStructureVector_rend(*args)
    def pop_back(*args): return _QuantLib.YieldTermStructureVector_pop_back(*args)
    def erase(*args): return _QuantLib.YieldTermStructureVector_erase(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_YieldTermStructureVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _QuantLib.YieldTermStructureVector_push_back(*args)
    def front(*args): return _QuantLib.YieldTermStructureVector_front(*args)
    def back(*args): return _QuantLib.YieldTermStructureVector_back(*args)
    def assign(*args): return _QuantLib.YieldTermStructureVector_assign(*args)
    def resize(*args): return _QuantLib.YieldTermStructureVector_resize(*args)
    def insert(*args): return _QuantLib.YieldTermStructureVector_insert(*args)
    def reserve(*args): return _QuantLib.YieldTermStructureVector_reserve(*args)
    def capacity(*args): return _QuantLib.YieldTermStructureVector_capacity(*args)
    __swig_destroy__ = _QuantLib.delete_YieldTermStructureVector
    __del__ = lambda self : None;
YieldTermStructureVector_swigregister = _QuantLib.YieldTermStructureVector_swigregister
YieldTermStructureVector_swigregister(YieldTermStructureVector)

class BlackVolTermStructureVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args): return _QuantLib.BlackVolTermStructureVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _QuantLib.BlackVolTermStructureVector___nonzero__(*args)
    def __len__(*args): return _QuantLib.BlackVolTermStructureVector___len__(*args)
    def pop(*args): return _QuantLib.BlackVolTermStructureVector_pop(*args)
    def __getslice__(*args): return _QuantLib.BlackVolTermStructureVector___getslice__(*args)
    def __setslice__(*args): return _QuantLib.BlackVolTermStructureVector___setslice__(*args)
    def __delslice__(*args): return _QuantLib.BlackVolTermStructureVector___delslice__(*args)
    def __delitem__(*args): return _QuantLib.BlackVolTermStructureVector___delitem__(*args)
    def __getitem__(*args): return _QuantLib.BlackVolTermStructureVector___getitem__(*args)
    def __setitem__(*args): return _QuantLib.BlackVolTermStructureVector___setitem__(*args)
    def append(*args): return _QuantLib.BlackVolTermStructureVector_append(*args)
    def empty(*args): return _QuantLib.BlackVolTermStructureVector_empty(*args)
    def size(*args): return _QuantLib.BlackVolTermStructureVector_size(*args)
    def clear(*args): return _QuantLib.BlackVolTermStructureVector_clear(*args)
    def swap(*args): return _QuantLib.BlackVolTermStructureVector_swap(*args)
    def get_allocator(*args): return _QuantLib.BlackVolTermStructureVector_get_allocator(*args)
    def begin(*args): return _QuantLib.BlackVolTermStructureVector_begin(*args)
    def end(*args): return _QuantLib.BlackVolTermStructureVector_end(*args)
    def rbegin(*args): return _QuantLib.BlackVolTermStructureVector_rbegin(*args)
    def rend(*args): return _QuantLib.BlackVolTermStructureVector_rend(*args)
    def pop_back(*args): return _QuantLib.BlackVolTermStructureVector_pop_back(*args)
    def erase(*args): return _QuantLib.BlackVolTermStructureVector_erase(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_BlackVolTermStructureVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _QuantLib.BlackVolTermStructureVector_push_back(*args)
    def front(*args): return _QuantLib.BlackVolTermStructureVector_front(*args)
    def back(*args): return _QuantLib.BlackVolTermStructureVector_back(*args)
    def assign(*args): return _QuantLib.BlackVolTermStructureVector_assign(*args)
    def resize(*args): return _QuantLib.BlackVolTermStructureVector_resize(*args)
    def insert(*args): return _QuantLib.BlackVolTermStructureVector_insert(*args)
    def reserve(*args): return _QuantLib.BlackVolTermStructureVector_reserve(*args)
    def capacity(*args): return _QuantLib.BlackVolTermStructureVector_capacity(*args)
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructureVector
    __del__ = lambda self : None;
BlackVolTermStructureVector_swigregister = _QuantLib.BlackVolTermStructureVector_swigregister
BlackVolTermStructureVector_swigregister(BlackVolTermStructureVector)

class McDiscreteArithmeticASO(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_McDiscreteArithmeticASO(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(*args): return _QuantLib.McDiscreteArithmeticASO_value(*args)
    def valueWithSamples(*args): return _QuantLib.McDiscreteArithmeticASO_valueWithSamples(*args)
    def errorEstimate(*args): return _QuantLib.McDiscreteArithmeticASO_errorEstimate(*args)
    __swig_destroy__ = _QuantLib.delete_McDiscreteArithmeticASO
    __del__ = lambda self : None;
McDiscreteArithmeticASO_swigregister = _QuantLib.McDiscreteArithmeticASO_swigregister
McDiscreteArithmeticASO_swigregister(McDiscreteArithmeticASO)

class McMaxBasket(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_McMaxBasket(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(*args): return _QuantLib.McMaxBasket_value(*args)
    def valueWithSamples(*args): return _QuantLib.McMaxBasket_valueWithSamples(*args)
    def errorEstimate(*args): return _QuantLib.McMaxBasket_errorEstimate(*args)
    __swig_destroy__ = _QuantLib.delete_McMaxBasket
    __del__ = lambda self : None;
McMaxBasket_swigregister = _QuantLib.McMaxBasket_swigregister
McMaxBasket_swigregister(McMaxBasket)

class McHimalaya(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_McHimalaya(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(*args): return _QuantLib.McHimalaya_value(*args)
    def valueWithSamples(*args): return _QuantLib.McHimalaya_valueWithSamples(*args)
    def errorEstimate(*args): return _QuantLib.McHimalaya_errorEstimate(*args)
    __swig_destroy__ = _QuantLib.delete_McHimalaya
    __del__ = lambda self : None;
McHimalaya_swigregister = _QuantLib.McHimalaya_swigregister
McHimalaya_swigregister(McHimalaya)

class McEverest(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_McEverest(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(*args): return _QuantLib.McEverest_value(*args)
    def valueWithSamples(*args): return _QuantLib.McEverest_valueWithSamples(*args)
    def errorEstimate(*args): return _QuantLib.McEverest_errorEstimate(*args)
    __swig_destroy__ = _QuantLib.delete_McEverest
    __del__ = lambda self : None;
McEverest_swigregister = _QuantLib.McEverest_swigregister
McEverest_swigregister(McEverest)

class McPagoda(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_McPagoda(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(*args): return _QuantLib.McPagoda_value(*args)
    def valueWithSamples(*args): return _QuantLib.McPagoda_valueWithSamples(*args)
    def errorEstimate(*args): return _QuantLib.McPagoda_errorEstimate(*args)
    __swig_destroy__ = _QuantLib.delete_McPagoda
    __del__ = lambda self : None;
McPagoda_swigregister = _QuantLib.McPagoda_swigregister
McPagoda_swigregister(McPagoda)

class SwaptionVolatilityStructure(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(*args): return _QuantLib.SwaptionVolatilityStructure___deref__(*args)
    def __nonzero__(*args): return _QuantLib.SwaptionVolatilityStructure___nonzero__(*args)
    def asObservable(*args): return _QuantLib.SwaptionVolatilityStructure_asObservable(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_SwaptionVolatilityStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructure
    __del__ = lambda self : None;
    def volatility(*args): return _QuantLib.SwaptionVolatilityStructure_volatility(*args)
SwaptionVolatilityStructure_swigregister = _QuantLib.SwaptionVolatilityStructure_swigregister
SwaptionVolatilityStructure_swigregister(SwaptionVolatilityStructure)

class SwaptionVolatilityStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SwaptionVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args): return _QuantLib.SwaptionVolatilityStructureHandle___deref__(*args)
    def linkTo(*args): return _QuantLib.SwaptionVolatilityStructureHandle_linkTo(*args)
    def __nonzero__(*args): return _QuantLib.SwaptionVolatilityStructureHandle___nonzero__(*args)
    def asObservable(*args): return _QuantLib.SwaptionVolatilityStructureHandle_asObservable(*args)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructureHandle
    __del__ = lambda self : None;
    def volatility(*args): return _QuantLib.SwaptionVolatilityStructureHandle_volatility(*args)
SwaptionVolatilityStructureHandle_swigregister = _QuantLib.SwaptionVolatilityStructureHandle_swigregister
SwaptionVolatilityStructureHandle_swigregister(SwaptionVolatilityStructureHandle)

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

class CapVolatilityStructure(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(*args): return _QuantLib.CapVolatilityStructure___deref__(*args)
    def __nonzero__(*args): return _QuantLib.CapVolatilityStructure___nonzero__(*args)
    def asObservable(*args): return _QuantLib.CapVolatilityStructure_asObservable(*args)
    def __init__(self, *args): 
        this = _QuantLib.new_CapVolatilityStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapVolatilityStructure
    __del__ = lambda self : None;
    def volatility(*args): return _QuantLib.CapVolatilityStructure_volatility(*args)
CapVolatilityStructure_swigregister = _QuantLib.CapVolatilityStructure_swigregister
CapVolatilityStructure_swigregister(CapVolatilityStructure)

class CapVolatilityStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args): return _QuantLib.CapVolatilityStructureHandle___deref__(*args)
    def linkTo(*args): return _QuantLib.CapVolatilityStructureHandle_linkTo(*args)
    def __nonzero__(*args): return _QuantLib.CapVolatilityStructureHandle___nonzero__(*args)
    def asObservable(*args): return _QuantLib.CapVolatilityStructureHandle_asObservable(*args)
    __swig_destroy__ = _QuantLib.delete_CapVolatilityStructureHandle
    __del__ = lambda self : None;
    def volatility(*args): return _QuantLib.CapVolatilityStructureHandle_volatility(*args)
CapVolatilityStructureHandle_swigregister = _QuantLib.CapVolatilityStructureHandle_swigregister
CapVolatilityStructureHandle_swigregister(CapVolatilityStructureHandle)

class CapVolatilityVector(CapVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapVolatilityVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapVolatilityVector
    __del__ = lambda self : None;
CapVolatilityVector_swigregister = _QuantLib.CapVolatilityVector_swigregister
CapVolatilityVector_swigregister(CapVolatilityVector)