# This file was created automatically by SWIG.
import QuantLibc
class Observable:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_ObservableHandle(self)
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Observable instance at %s>" % (self.this,)
class ObservablePtr(Observable):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Observable



class Observer:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Observer,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_PyObserver(self)
    def registerWith(*args, **kwargs):
        val = apply(QuantLibc.Observer_registerWith,args, kwargs)
        return val
    def unregisterWith(*args, **kwargs):
        val = apply(QuantLibc.Observer_unregisterWith,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Observer instance at %s>" % (self.this,)
class ObserverPtr(Observer):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Observer



class MarketElement(Observable):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_MarketElement,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_MarketElementHandle(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.MarketElement_value,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.MarketElement___nonzero__,args, kwargs)
        return val
    def notifyObservers(*args, **kwargs):
        val = apply(QuantLibc.MarketElement_notifyObservers,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C MarketElement instance at %s>" % (self.this,)
class MarketElementPtr(MarketElement):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = MarketElement



class MarketElementHandle:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_MarketElementHandle,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_MarketElementRelinkableHandle(self)
    def linkTo(*args, **kwargs):
        val = apply(QuantLibc.MarketElementHandle_linkTo,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.MarketElementHandle___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C MarketElementHandle instance at %s>" % (self.this,)
class MarketElementHandlePtr(MarketElementHandle):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = MarketElementHandle



class SimpleMarketElement(MarketElement):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SimpleMarketElement,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SimpleMarketElementHandle(self)
    def setValue(*args, **kwargs):
        val = apply(QuantLibc.SimpleMarketElement_setValue,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [MarketElement]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [MarketElement]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SimpleMarketElement instance at %s>" % (self.this,)
class SimpleMarketElementPtr(SimpleMarketElement):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SimpleMarketElement



class DerivedMarketElement(MarketElement):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DerivedMarketElement,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DerivedMarketElementHandle(self)
    __setmethods__ = {}
    for _s in [MarketElement]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [MarketElement]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DerivedMarketElement instance at %s>" % (self.this,)
class DerivedMarketElementPtr(DerivedMarketElement):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DerivedMarketElement



class CompositeMarketElement(MarketElement):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CompositeMarketElement,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CompositeMarketElementHandle(self)
    __setmethods__ = {}
    for _s in [MarketElement]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [MarketElement]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CompositeMarketElement instance at %s>" % (self.this,)
class CompositeMarketElementPtr(CompositeMarketElement):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CompositeMarketElement



class Instrument(Observable):
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_InstrumentHandle(self)
    def isinCode(*args, **kwargs):
        val = apply(QuantLibc.Instrument_isinCode,args, kwargs)
        return val
    def description(*args, **kwargs):
        val = apply(QuantLibc.Instrument_description,args, kwargs)
        return val
    def NPV(*args, **kwargs):
        val = apply(QuantLibc.Instrument_NPV,args, kwargs)
        return val
    def isExpired(*args, **kwargs):
        val = apply(QuantLibc.Instrument_isExpired,args, kwargs)
        return val
    def recalculate(*args, **kwargs):
        val = apply(QuantLibc.Instrument_recalculate,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Instrument___str__,args, kwargs)
        return val
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.Instrument___cmp__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.Instrument___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Instrument instance at %s>" % (self.this,)
class InstrumentPtr(Instrument):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Instrument



class Stock(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Stock,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_StockHandle(self)
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Stock instance at %s>" % (self.this,)
class StockPtr(Stock):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Stock



class IntVector:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_IntVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_IntVector(self)
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___str__,args, kwargs)
        return val
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___getitem__,args, kwargs)
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___setitem__,args, kwargs)
        return val
    def __getslice__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___getslice__,args, kwargs)
        if val: val = IntVectorPtr(val) ; val.thisown = 1
        return val
    def __setslice__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___setslice__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.IntVector___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C IntVector instance at %s>" % (self.this,)
class IntVectorPtr(IntVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = IntVector



class DoubleVector:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DoubleVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DoubleVector(self)
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___str__,args, kwargs)
        return val
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___getitem__,args, kwargs)
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___setitem__,args, kwargs)
        return val
    def __getslice__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___getslice__,args, kwargs)
        if val: val = DoubleVectorPtr(val) ; val.thisown = 1
        return val
    def __setslice__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___setslice__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.DoubleVector___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DoubleVector instance at %s>" % (self.this,)
class DoubleVectorPtr(DoubleVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DoubleVector



class Period:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Period,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Period(self)
    def length(*args, **kwargs):
        val = apply(QuantLibc.Period_length,args, kwargs)
        return val
    def units(*args, **kwargs):
        val = apply(QuantLibc.Period_units,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Period___str__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Period instance at %s>" % (self.this,)
class PeriodPtr(Period):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Period



class Date:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Date,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Date(self)
    def weekday(*args, **kwargs):
        val = apply(QuantLibc.Date_weekday,args, kwargs)
        return val
    def dayOfMonth(*args, **kwargs):
        val = apply(QuantLibc.Date_dayOfMonth,args, kwargs)
        return val
    def dayOfYear(*args, **kwargs):
        val = apply(QuantLibc.Date_dayOfYear,args, kwargs)
        return val
    def month(*args, **kwargs):
        val = apply(QuantLibc.Date_month,args, kwargs)
        return val
    def year(*args, **kwargs):
        val = apply(QuantLibc.Date_year,args, kwargs)
        return val
    def serialNumber(*args, **kwargs):
        val = apply(QuantLibc.Date_serialNumber,args, kwargs)
        return val
    def plusDays(*args, **kwargs):
        val = apply(QuantLibc.Date_plusDays,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def plusWeeks(*args, **kwargs):
        val = apply(QuantLibc.Date_plusWeeks,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def plusMonths(*args, **kwargs):
        val = apply(QuantLibc.Date_plusMonths,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def plusYears(*args, **kwargs):
        val = apply(QuantLibc.Date_plusYears,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def plus(*args, **kwargs):
        val = apply(QuantLibc.Date_plus,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def monthNumber(*args, **kwargs):
        val = apply(QuantLibc.Date_monthNumber,args, kwargs)
        return val
    def weekdayNumber(*args, **kwargs):
        val = apply(QuantLibc.Date_weekdayNumber,args, kwargs)
        return val
    def __add__(*args, **kwargs):
        val = apply(QuantLibc.Date___add__,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __sub__(*args, **kwargs):
        val = apply(QuantLibc.Date___sub__,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.Date___cmp__,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Date___str__,args, kwargs)
        return val
    def __repr__(*args, **kwargs):
        val = apply(QuantLibc.Date___repr__,args, kwargs)
        return val
    def __iadd__(*args, **kwargs):
        val = apply(QuantLibc.Date___iadd__,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __isub__(*args, **kwargs):
        val = apply(QuantLibc.Date___isub__,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.Date___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
class DatePtr(Date):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Date



class DateVector:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DateVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DateVector(self)
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___getitem__,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___setitem__,args, kwargs)
        return val
    def __getslice__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___getslice__,args, kwargs)
        if val: val = DateVectorPtr(val) ; val.thisown = 1
        return val
    def __setslice__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___setslice__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___nonzero__,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.DateVector___str__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DateVector instance at %s>" % (self.this,)
class DateVectorPtr(DateVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DateVector



class Calendar:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Calendar,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Calendar(self)
    def isBusinessDay(*args, **kwargs):
        val = apply(QuantLibc.Calendar_isBusinessDay,args, kwargs)
        return val
    def isHoliday(*args, **kwargs):
        val = apply(QuantLibc.Calendar_isHoliday,args, kwargs)
        return val
    def roll(*args, **kwargs):
        val = apply(QuantLibc.Calendar_roll,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def advance(*args, **kwargs):
        val = apply(QuantLibc.Calendar_advance,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Calendar___str__,args, kwargs)
        return val
    def __repr__(*args, **kwargs):
        val = apply(QuantLibc.Calendar___repr__,args, kwargs)
        return val
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.Calendar___cmp__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
class CalendarPtr(Calendar):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Calendar



class DayCounter:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DayCounter,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DayCounter(self)
    def dayCount(*args, **kwargs):
        val = apply(QuantLibc.DayCounter_dayCount,args, kwargs)
        return val
    def yearFraction(*args, **kwargs):
        val = apply(QuantLibc.DayCounter_yearFraction,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.DayCounter___str__,args, kwargs)
        return val
    def __repr__(*args, **kwargs):
        val = apply(QuantLibc.DayCounter___repr__,args, kwargs)
        return val
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.DayCounter___cmp__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
class DayCounterPtr(DayCounter):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DayCounter



class TermStructure(Observable):
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_TermStructureHandle(self)
    def currency(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_currency,args, kwargs)
        return val
    def todaysDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_todaysDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def calendar(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_calendar,args, kwargs)
        if val: val = CalendarPtr(val) ; val.thisown = 1
        return val
    def dayCounter(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_dayCounter,args, kwargs)
        if val: val = DayCounterPtr(val) ; val.thisown = 1
        return val
    def settlementDays(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_settlementDays,args, kwargs)
        return val
    def settlementDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_settlementDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def maxDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_maxDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def minDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_minDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def maxTime(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_maxTime,args, kwargs)
        return val
    def minTime(*args, **kwargs):
        val = apply(QuantLibc.TermStructure_minTime,args, kwargs)
        return val
    def _zeroYieldVsDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure__zeroYieldVsDate,args, kwargs)
        return val
    def _zeroYieldVsTime(*args, **kwargs):
        val = apply(QuantLibc.TermStructure__zeroYieldVsTime,args, kwargs)
        return val
    def _discountVsDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure__discountVsDate,args, kwargs)
        return val
    def _discountVsTime(*args, **kwargs):
        val = apply(QuantLibc.TermStructure__discountVsTime,args, kwargs)
        return val
    def _forwardVsDate(*args, **kwargs):
        val = apply(QuantLibc.TermStructure__forwardVsDate,args, kwargs)
        return val
    def _forwardVsTime(*args, **kwargs):
        val = apply(QuantLibc.TermStructure__forwardVsTime,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.TermStructure___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C TermStructure instance at %s>" % (self.this,)
class TermStructurePtr(TermStructure):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = TermStructure



class TermStructureHandle(Observable):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_TermStructureHandle,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_TermStructureRelinkableHandle(self)
    def linkTo(*args, **kwargs):
        val = apply(QuantLibc.TermStructureHandle_linkTo,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.TermStructureHandle___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C TermStructureHandle instance at %s>" % (self.this,)
class TermStructureHandlePtr(TermStructureHandle):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = TermStructureHandle



class ImpliedTermStructure(TermStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_ImpliedTermStructure,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_ImpliedTermStructureHandle(self)
    __setmethods__ = {}
    for _s in [TermStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TermStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C ImpliedTermStructure instance at %s>" % (self.this,)
class ImpliedTermStructurePtr(ImpliedTermStructure):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = ImpliedTermStructure



class ZeroSpreadedTermStructure(TermStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_ZeroSpreadedTermStructure,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_ZeroSpreadedTermStructureHandle(self)
    __setmethods__ = {}
    for _s in [TermStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TermStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C ZeroSpreadedTermStructure instance at %s>" % (self.this,)
class ZeroSpreadedTermStructurePtr(ZeroSpreadedTermStructure):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = ZeroSpreadedTermStructure



class ForwardSpreadedTermStructure(TermStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_ForwardSpreadedTermStructure,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_ForwardSpreadedTermStructureHandle(self)
    __setmethods__ = {}
    for _s in [TermStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TermStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C ForwardSpreadedTermStructure instance at %s>" % (self.this,)
class ForwardSpreadedTermStructurePtr(ForwardSpreadedTermStructure):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = ForwardSpreadedTermStructure



class FlatForward(TermStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FlatForward,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FlatForwardHandle(self)
    __setmethods__ = {}
    for _s in [TermStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TermStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FlatForward instance at %s>" % (self.this,)
class FlatForwardPtr(FlatForward):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FlatForward



class OptionEngineHandle:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_OptionEngineHandle(self)
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C OptionEngineHandle instance at %s>" % (self.this,)
class OptionEngineHandlePtr(OptionEngineHandle):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = OptionEngineHandle



class PlainOption(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_PlainOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_PlainOptionHandle(self)
    def delta(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.PlainOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C PlainOption instance at %s>" % (self.this,)
class PlainOptionPtr(PlainOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = PlainOption



class EuropeanEngine(OptionEngineHandle):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_EuropeanEngine,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_EuropeanEngineHandle(self)
    __setmethods__ = {}
    for _s in [OptionEngineHandle]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [OptionEngineHandle]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C EuropeanEngine instance at %s>" % (self.this,)
class EuropeanEnginePtr(EuropeanEngine):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = EuropeanEngine



class Exercise:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Exercise,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Exercise(self)
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Exercise instance at %s>" % (self.this,)
class ExercisePtr(Exercise):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Exercise



class EuropeanExercise(Exercise):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_EuropeanExercise,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_EuropeanExercise(self)
    __setmethods__ = {}
    for _s in [Exercise]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Exercise]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C EuropeanExercise instance at %s>" % (self.this,)
class EuropeanExercisePtr(EuropeanExercise):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = EuropeanExercise



class AmericanExercise(Exercise):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_AmericanExercise,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_AmericanExercise(self)
    __setmethods__ = {}
    for _s in [Exercise]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Exercise]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C AmericanExercise instance at %s>" % (self.this,)
class AmericanExercisePtr(AmericanExercise):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = AmericanExercise



class BermudanExercise(Exercise):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BermudanExercise,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BermudanExercise(self)
    __setmethods__ = {}
    for _s in [Exercise]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Exercise]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BermudanExercise instance at %s>" % (self.this,)
class BermudanExercisePtr(BermudanExercise):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BermudanExercise



class HistoryEntry:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_HistoryEntry(self)
    def date(*args, **kwargs):
        val = apply(QuantLibc.HistoryEntry_date,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def value(*args, **kwargs):
        val = apply(QuantLibc.HistoryEntry_value,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.HistoryEntry___str__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C HistoryEntry instance at %s>" % (self.this,)
class HistoryEntryPtr(HistoryEntry):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = HistoryEntry



class HistoryIterator:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_HistoryIterator(self)
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.HistoryIterator___cmp__,args, kwargs)
        return val
    def _value(*args, **kwargs):
        val = apply(QuantLibc.HistoryIterator__value,args, kwargs)
        if val: val = HistoryEntryPtr(val) ; val.thisown = 1
        return val
    def _advance(*args, **kwargs):
        val = apply(QuantLibc.HistoryIterator__advance,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C HistoryIterator instance at %s>" % (self.this,)
class HistoryIteratorPtr(HistoryIterator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = HistoryIterator



class HistoryValidIterator:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_HistoryValidIterator(self)
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.HistoryValidIterator___cmp__,args, kwargs)
        return val
    def _value(*args, **kwargs):
        val = apply(QuantLibc.HistoryValidIterator__value,args, kwargs)
        if val: val = HistoryEntryPtr(val) ; val.thisown = 1
        return val
    def _advance(*args, **kwargs):
        val = apply(QuantLibc.HistoryValidIterator__advance,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C HistoryValidIterator instance at %s>" % (self.this,)
class HistoryValidIteratorPtr(HistoryValidIterator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = HistoryValidIterator



class HistoryDataIterator:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_HistoryDataIterator(self)
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.HistoryDataIterator___cmp__,args, kwargs)
        return val
    def _value(*args, **kwargs):
        val = apply(QuantLibc.HistoryDataIterator__value,args, kwargs)
        return val
    def _advance(*args, **kwargs):
        val = apply(QuantLibc.HistoryDataIterator__advance,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C HistoryDataIterator instance at %s>" % (self.this,)
class HistoryDataIteratorPtr(HistoryDataIterator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = HistoryDataIterator



class HistoryValidDataIterator:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_HistoryValidDataIterator(self)
    def __cmp__(*args, **kwargs):
        val = apply(QuantLibc.HistoryValidDataIterator___cmp__,args, kwargs)
        return val
    def _value(*args, **kwargs):
        val = apply(QuantLibc.HistoryValidDataIterator__value,args, kwargs)
        return val
    def _advance(*args, **kwargs):
        val = apply(QuantLibc.HistoryValidDataIterator__advance,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C HistoryValidDataIterator instance at %s>" % (self.this,)
class HistoryValidDataIteratorPtr(HistoryValidDataIterator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = HistoryValidDataIterator



class History:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_History,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_History(self)
    def firstDate(*args, **kwargs):
        val = apply(QuantLibc.History_firstDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def lastDate(*args, **kwargs):
        val = apply(QuantLibc.History_lastDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.History___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.History___getitem__,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.History___str__,args, kwargs)
        return val
    def _begin(*args, **kwargs):
        val = apply(QuantLibc.History__begin,args, kwargs)
        if val: val = HistoryIteratorPtr(val) ; val.thisown = 1
        return val
    def _end(*args, **kwargs):
        val = apply(QuantLibc.History__end,args, kwargs)
        if val: val = HistoryIteratorPtr(val) ; val.thisown = 1
        return val
    def _iterator(*args, **kwargs):
        val = apply(QuantLibc.History__iterator,args, kwargs)
        if val: val = HistoryIteratorPtr(val) ; val.thisown = 1
        return val
    def _vbegin(*args, **kwargs):
        val = apply(QuantLibc.History__vbegin,args, kwargs)
        if val: val = HistoryValidIteratorPtr(val) ; val.thisown = 1
        return val
    def _vend(*args, **kwargs):
        val = apply(QuantLibc.History__vend,args, kwargs)
        if val: val = HistoryValidIteratorPtr(val) ; val.thisown = 1
        return val
    def _valid_iterator(*args, **kwargs):
        val = apply(QuantLibc.History__valid_iterator,args, kwargs)
        if val: val = HistoryValidIteratorPtr(val) ; val.thisown = 1
        return val
    def _dbegin(*args, **kwargs):
        val = apply(QuantLibc.History__dbegin,args, kwargs)
        if val: val = HistoryDataIteratorPtr(val) ; val.thisown = 1
        return val
    def _dend(*args, **kwargs):
        val = apply(QuantLibc.History__dend,args, kwargs)
        if val: val = HistoryDataIteratorPtr(val) ; val.thisown = 1
        return val
    def _data_iterator(*args, **kwargs):
        val = apply(QuantLibc.History__data_iterator,args, kwargs)
        if val: val = HistoryDataIteratorPtr(val) ; val.thisown = 1
        return val
    def _vdbegin(*args, **kwargs):
        val = apply(QuantLibc.History__vdbegin,args, kwargs)
        if val: val = HistoryValidDataIteratorPtr(val) ; val.thisown = 1
        return val
    def _vdend(*args, **kwargs):
        val = apply(QuantLibc.History__vdend,args, kwargs)
        if val: val = HistoryValidDataIteratorPtr(val) ; val.thisown = 1
        return val
    def _valid_data_iterator(*args, **kwargs):
        val = apply(QuantLibc.History__valid_data_iterator,args, kwargs)
        if val: val = HistoryValidDataIteratorPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C History instance at %s>" % (self.this,)
class HistoryPtr(History):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = History



class XiborManagerClass:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_XiborManagerClass,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_XiborManagerClass(self)
    def setHistory(*args, **kwargs):
        val = apply(QuantLibc.XiborManagerClass_setHistory,args, kwargs)
        return val
    def getHistory(*args, **kwargs):
        val = apply(QuantLibc.XiborManagerClass_getHistory,args, kwargs)
        if val: val = HistoryPtr(val) ; val.thisown = 1
        return val
    def hasHistory(*args, **kwargs):
        val = apply(QuantLibc.XiborManagerClass_hasHistory,args, kwargs)
        return val
    def histories(*args, **kwargs):
        val = apply(QuantLibc.XiborManagerClass_histories,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C XiborManagerClass instance at %s>" % (self.this,)
class XiborManagerClassPtr(XiborManagerClass):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = XiborManagerClass



class Index:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_IndexHandle(self)
    def fixing(*args, **kwargs):
        val = apply(QuantLibc.Index_fixing,args, kwargs)
        return val
    def name(*args, **kwargs):
        val = apply(QuantLibc.Index_name,args, kwargs)
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Index___str__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Index instance at %s>" % (self.this,)
class IndexPtr(Index):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Index



class Xibor(Index):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Xibor,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_XiborHandle(self)
    def tenor(*args, **kwargs):
        val = apply(QuantLibc.Xibor_tenor,args, kwargs)
        if val: val = PeriodPtr(val) ; val.thisown = 1
        return val
    def currency(*args, **kwargs):
        val = apply(QuantLibc.Xibor_currency,args, kwargs)
        return val
    def calendar(*args, **kwargs):
        val = apply(QuantLibc.Xibor_calendar,args, kwargs)
        if val: val = CalendarPtr(val) ; val.thisown = 1
        return val
    def isAdjusted(*args, **kwargs):
        val = apply(QuantLibc.Xibor_isAdjusted,args, kwargs)
        return val
    def rollingConvention(*args, **kwargs):
        val = apply(QuantLibc.Xibor_rollingConvention,args, kwargs)
        return val
    def dayCounter(*args, **kwargs):
        val = apply(QuantLibc.Xibor_dayCounter,args, kwargs)
        if val: val = DayCounterPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in [Index]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Index]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Xibor instance at %s>" % (self.this,)
class XiborPtr(Xibor):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Xibor



class CashFlow(Observable):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CashFlow,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CashFlowHandle(self)
    def amount(*args, **kwargs):
        val = apply(QuantLibc.CashFlow_amount,args, kwargs)
        return val
    def date(*args, **kwargs):
        val = apply(QuantLibc.CashFlow_date,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def notifyObservers(*args, **kwargs):
        val = apply(QuantLibc.CashFlow_notifyObservers,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CashFlow instance at %s>" % (self.this,)
class CashFlowPtr(CashFlow):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CashFlow



class SimpleCashFlow(CashFlow):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SimpleCashFlow,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SimpleCashFlowHandle(self)
    __setmethods__ = {}
    for _s in [CashFlow]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [CashFlow]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SimpleCashFlow instance at %s>" % (self.this,)
class SimpleCashFlowPtr(SimpleCashFlow):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SimpleCashFlow



class FixedRateCoupon(CashFlow):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FixedRateCoupon,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FixedRateCouponHandle(self)
    __setmethods__ = {}
    for _s in [CashFlow]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [CashFlow]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FixedRateCoupon instance at %s>" % (self.this,)
class FixedRateCouponPtr(FixedRateCoupon):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FixedRateCoupon



class FloatingRateCoupon(CashFlow):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FloatingRateCoupon,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FloatingRateCouponHandle(self)
    __setmethods__ = {}
    for _s in [CashFlow]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [CashFlow]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FloatingRateCoupon instance at %s>" % (self.this,)
class FloatingRateCouponPtr(FloatingRateCoupon):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FloatingRateCoupon



class CashFlowVector:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CashFlowVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CashFlowHandleVector(self)
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.CashFlowVector___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.CashFlowVector___getitem__,args, kwargs)
        if val: val = CashFlowPtr(val) ; val.thisown = 1
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.CashFlowVector___setitem__,args, kwargs)
        return val
    def __getslice__(*args, **kwargs):
        val = apply(QuantLibc.CashFlowVector___getslice__,args, kwargs)
        if val: val = CashFlowVectorPtr(val) ; val.thisown = 1
        return val
    def __setslice__(*args, **kwargs):
        val = apply(QuantLibc.CashFlowVector___setslice__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.CashFlowVector___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CashFlowVector instance at %s>" % (self.this,)
class CashFlowVectorPtr(CashFlowVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CashFlowVector



class FixedRateCouponVector(CashFlowVector):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FixedRateCouponVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FixedRateCouponVector(self)
    __setmethods__ = {}
    for _s in [CashFlowVector]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [CashFlowVector]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FixedRateCouponVector instance at %s>" % (self.this,)
class FixedRateCouponVectorPtr(FixedRateCouponVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FixedRateCouponVector



class FloatingRateCouponVector(CashFlowVector):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FloatingRateCouponVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FloatingRateCouponVector(self)
    __setmethods__ = {}
    for _s in [CashFlowVector]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [CashFlowVector]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FloatingRateCouponVector instance at %s>" % (self.this,)
class FloatingRateCouponVectorPtr(FloatingRateCouponVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FloatingRateCouponVector



class Swap(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Swap,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SwapHandle(self)
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Swap instance at %s>" % (self.this,)
class SwapPtr(Swap):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Swap



class SimpleSwap(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SimpleSwap,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SimpleSwapHandle(self)
    def fairRate(*args, **kwargs):
        val = apply(QuantLibc.SimpleSwap_fairRate,args, kwargs)
        return val
    def fixedLegBPS(*args, **kwargs):
        val = apply(QuantLibc.SimpleSwap_fixedLegBPS,args, kwargs)
        return val
    def floatingLegBPS(*args, **kwargs):
        val = apply(QuantLibc.SimpleSwap_floatingLegBPS,args, kwargs)
        return val
    def maturity(*args, **kwargs):
        val = apply(QuantLibc.SimpleSwap_maturity,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SimpleSwap instance at %s>" % (self.this,)
class SimpleSwapPtr(SimpleSwap):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SimpleSwap



class Swaption(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Swaption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Swaption(self)
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Swaption instance at %s>" % (self.this,)
class SwaptionPtr(Swaption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Swaption



class Cap(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Cap,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_VanillaCapHandle(self)
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Cap instance at %s>" % (self.this,)
class CapPtr(Cap):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Cap



class Floor(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Floor,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_VanillaFloorHandle(self)
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Floor instance at %s>" % (self.this,)
class FloorPtr(Floor):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Floor



class Collar(Instrument):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Collar,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_VanillaCollarHandle(self)
    __setmethods__ = {}
    for _s in [Instrument]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Instrument]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Collar instance at %s>" % (self.this,)
class CollarPtr(Collar):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Collar



class BlackModel(Observable):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BlackModel,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BlackModelHandle(self)
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BlackModel instance at %s>" % (self.this,)
class BlackModelPtr(BlackModel):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BlackModel



class BlackSwaptionEngine(OptionEngineHandle):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BlackSwaptionEngine,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BlackSwaptionHandle(self)
    __setmethods__ = {}
    for _s in [OptionEngineHandle]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [OptionEngineHandle]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BlackSwaptionEngine instance at %s>" % (self.this,)
class BlackSwaptionEnginePtr(BlackSwaptionEngine):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BlackSwaptionEngine



class BlackCapFloorEngine(OptionEngineHandle):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BlackCapFloorEngine,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BlackCapFloorHandle(self)
    __setmethods__ = {}
    for _s in [OptionEngineHandle]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [OptionEngineHandle]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BlackCapFloorEngine instance at %s>" % (self.this,)
class BlackCapFloorEnginePtr(BlackCapFloorEngine):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BlackCapFloorEngine



class BoundaryCondition:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BoundaryCondition,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BoundaryCondition(self)
    def type(*args, **kwargs):
        val = apply(QuantLibc.BoundaryCondition_type,args, kwargs)
        return val
    def value(*args, **kwargs):
        val = apply(QuantLibc.BoundaryCondition_value,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BoundaryCondition instance at %s>" % (self.this,)
class BoundaryConditionPtr(BoundaryCondition):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BoundaryCondition



class NormalDistribution:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_NormalDistribution,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_NormalDistribution(self)
    def derivative(*args, **kwargs):
        val = apply(QuantLibc.NormalDistribution_derivative,args, kwargs)
        return val
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.NormalDistribution___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C NormalDistribution instance at %s>" % (self.this,)
class NormalDistributionPtr(NormalDistribution):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = NormalDistribution



class CumulativeNormalDistribution:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CumulativeNormalDistribution,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CumulativeNormalDistribution(self)
    def derivative(*args, **kwargs):
        val = apply(QuantLibc.CumulativeNormalDistribution_derivative,args, kwargs)
        return val
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.CumulativeNormalDistribution___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CumulativeNormalDistribution instance at %s>" % (self.this,)
class CumulativeNormalDistributionPtr(CumulativeNormalDistribution):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CumulativeNormalDistribution



class InvCumulativeNormalDistribution:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_InvCumulativeNormalDistribution,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_InvCumulativeNormalDistribution(self)
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.InvCumulativeNormalDistribution___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C InvCumulativeNormalDistribution instance at %s>" % (self.this,)
class InvCumulativeNormalDistributionPtr(InvCumulativeNormalDistribution):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = InvCumulativeNormalDistribution



class FdEuropean:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdEuropean,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdEuropean(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_dividendRho,args, kwargs)
        return val
    def getGrid(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_getGrid,args, kwargs)
        return val
    def getPrices(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_getPrices,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdEuropean_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdEuropean instance at %s>" % (self.this,)
class FdEuropeanPtr(FdEuropean):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdEuropean



class FdAmericanOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdAmericanOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdAmericanOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdAmericanOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdAmericanOption instance at %s>" % (self.this,)
class FdAmericanOptionPtr(FdAmericanOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdAmericanOption



class FdShoutOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdShoutOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdShoutOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdShoutOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdShoutOption instance at %s>" % (self.this,)
class FdShoutOptionPtr(FdShoutOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdShoutOption



class FdBermudanOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdBermudanOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdBermudanOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdBermudanOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdBermudanOption instance at %s>" % (self.this,)
class FdBermudanOptionPtr(FdBermudanOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdBermudanOption



class FdDividendShoutOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdDividendShoutOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdDividendShoutOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_dividendRho,args, kwargs)
        return val
    def controlVariateCorrection(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_controlVariateCorrection,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdDividendShoutOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdDividendShoutOption instance at %s>" % (self.this,)
class FdDividendShoutOptionPtr(FdDividendShoutOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdDividendShoutOption



class FdDividendAmericanOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdDividendAmericanOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdDividendAmericanOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_dividendRho,args, kwargs)
        return val
    def controlVariateCorrection(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_controlVariateCorrection,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdDividendAmericanOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdDividendAmericanOption instance at %s>" % (self.this,)
class FdDividendAmericanOptionPtr(FdDividendAmericanOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdDividendAmericanOption



class FdDividendEuropeanOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FdDividendEuropeanOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FdDividendEuropeanOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.FdDividendEuropeanOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FdDividendEuropeanOption instance at %s>" % (self.this,)
class FdDividendEuropeanOptionPtr(FdDividendEuropeanOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FdDividendEuropeanOption



class Array:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Array,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Array(self)
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Array___str__,args, kwargs)
        return val
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.Array___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.Array___getitem__,args, kwargs)
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.Array___setitem__,args, kwargs)
        return val
    def __getslice__(*args, **kwargs):
        val = apply(QuantLibc.Array___getslice__,args, kwargs)
        if val: val = ArrayPtr(val) ; val.thisown = 1
        return val
    def __setslice__(*args, **kwargs):
        val = apply(QuantLibc.Array___setslice__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.Array___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Array instance at %s>" % (self.this,)
class ArrayPtr(Array):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Array



class LexicographicalViewColumn:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_LexicographicalViewColumn(self)
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.LexicographicalViewColumn___getitem__,args, kwargs)
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.LexicographicalViewColumn___setitem__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C LexicographicalViewColumn instance at %s>" % (self.this,)
class LexicographicalViewColumnPtr(LexicographicalViewColumn):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = LexicographicalViewColumn



class LexicographicalView:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_LexicographicalView,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_LexicographicalView(self)
    def xSize(*args, **kwargs):
        val = apply(QuantLibc.LexicographicalView_xSize,args, kwargs)
        return val
    def ySize(*args, **kwargs):
        val = apply(QuantLibc.LexicographicalView_ySize,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.LexicographicalView___getitem__,args, kwargs)
        if val: val = LexicographicalViewColumnPtr(val) ; val.thisown = 1
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.LexicographicalView___str__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C LexicographicalView instance at %s>" % (self.this,)
class LexicographicalViewPtr(LexicographicalView):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = LexicographicalView



class MatrixRow:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_MatrixRow(self)
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.MatrixRow___getitem__,args, kwargs)
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.MatrixRow___setitem__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C MatrixRow instance at %s>" % (self.this,)
class MatrixRowPtr(MatrixRow):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = MatrixRow



class Matrix:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Matrix,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Matrix(self)
    def rows(*args, **kwargs):
        val = apply(QuantLibc.Matrix_rows,args, kwargs)
        return val
    def columns(*args, **kwargs):
        val = apply(QuantLibc.Matrix_columns,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___getitem__,args, kwargs)
        if val: val = MatrixRowPtr(val) ; val.thisown = 1
        return val
    def __add__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___add__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __iadd__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___iadd__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __sub__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___sub__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __isub__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___isub__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __mul__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___mul__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __imul__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___imul__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __rmul__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___rmul__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __div__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___div__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __idiv__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___idiv__,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def __str__(*args, **kwargs):
        val = apply(QuantLibc.Matrix___str__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Matrix instance at %s>" % (self.this,)
class MatrixPtr(Matrix):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Matrix



class LinearInterpolation:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_LinearInterpolation,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_PyLinearInterpolation(self)
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.LinearInterpolation___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C LinearInterpolation instance at %s>" % (self.this,)
class LinearInterpolationPtr(LinearInterpolation):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = LinearInterpolation



class CubicSpline:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CubicSpline,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_PyCubicSpline(self)
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.CubicSpline___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CubicSpline instance at %s>" % (self.this,)
class CubicSplinePtr(CubicSpline):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CubicSpline



class BilinearInterpolation:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BilinearInterpolation,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_PyBilinearInterpolation(self)
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.BilinearInterpolation___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BilinearInterpolation instance at %s>" % (self.this,)
class BilinearInterpolationPtr(BilinearInterpolation):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BilinearInterpolation



class McEuropean:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McEuropean,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McEuropean(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McEuropean_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McEuropean_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McEuropean_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McEuropean instance at %s>" % (self.this,)
class McEuropeanPtr(McEuropean):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McEuropean



class McDiscreteArithmeticAPO:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McDiscreteArithmeticAPO,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McDiscreteArithmeticAPO(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McDiscreteArithmeticAPO_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McDiscreteArithmeticAPO_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McDiscreteArithmeticAPO_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McDiscreteArithmeticAPO instance at %s>" % (self.this,)
class McDiscreteArithmeticAPOPtr(McDiscreteArithmeticAPO):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McDiscreteArithmeticAPO



class McDiscreteArithmeticASO:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McDiscreteArithmeticASO,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McDiscreteArithmeticASO(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McDiscreteArithmeticASO_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McDiscreteArithmeticASO_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McDiscreteArithmeticASO_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McDiscreteArithmeticASO instance at %s>" % (self.this,)
class McDiscreteArithmeticASOPtr(McDiscreteArithmeticASO):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McDiscreteArithmeticASO



class McBasket:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McBasket,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McBasket(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McBasket_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McBasket_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McBasket_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McBasket instance at %s>" % (self.this,)
class McBasketPtr(McBasket):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McBasket



class McMaxBasket:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McMaxBasket,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McMaxBasket(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McMaxBasket_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McMaxBasket_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McMaxBasket_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McMaxBasket instance at %s>" % (self.this,)
class McMaxBasketPtr(McMaxBasket):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McMaxBasket



class McHimalaya:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McHimalaya,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McHimalaya(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McHimalaya_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McHimalaya_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McHimalaya_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McHimalaya instance at %s>" % (self.this,)
class McHimalayaPtr(McHimalaya):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McHimalaya



class McEverest:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McEverest,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McEverest(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McEverest_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McEverest_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McEverest_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McEverest instance at %s>" % (self.this,)
class McEverestPtr(McEverest):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McEverest



class McPagoda:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_McPagoda,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_McPagoda(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.McPagoda_value,args, kwargs)
        return val
    def valueWithSamples(*args, **kwargs):
        val = apply(QuantLibc.McPagoda_valueWithSamples,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.McPagoda_errorEstimate,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C McPagoda instance at %s>" % (self.this,)
class McPagodaPtr(McPagoda):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = McPagoda



class Path:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Path(self)
    def drift(*args, **kwargs):
        val = apply(QuantLibc.Path_drift,args, kwargs)
        if val: val = ArrayPtr(val) ; val.thisown = 1
        return val
    def diffusion(*args, **kwargs):
        val = apply(QuantLibc.Path_diffusion,args, kwargs)
        if val: val = ArrayPtr(val) ; val.thisown = 1
        return val
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.Path___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.Path___getitem__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Path instance at %s>" % (self.this,)
class PathPtr(Path):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Path



class SamplePath:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SamplePath(self)
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __setmethods__.update({
        "value" : QuantLibc.SamplePath_value_set,
        "weight" : QuantLibc.SamplePath_weight_set,
    })
    def __setattr__(self,name,value):
        if (name == "this") or (name == "thisown"): self.__dict__[name] = value; return
        method = SamplePath.__setmethods__.get(name,None)
        if method: return method(self,value)
        self.__dict__[name] = value
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    __getmethods__.update({
        "value" : lambda x : PathPtr(QuantLibc.SamplePath_value_get(x)),
        "weight" : QuantLibc.SamplePath_weight_get,
    })
    def __getattr__(self,name):
        method = SamplePath.__getmethods__.get(name,None)
        if method: return method(self)
        raise AttributeError,name
    def __repr__(self):
        return "<C SamplePath instance at %s>" % (self.this,)
class SamplePathPtr(SamplePath):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SamplePath



class GaussianPathGenerator:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_GaussianPathGenerator,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_GaussianPathGenerator(self)
    def next(*args, **kwargs):
        val = apply(QuantLibc.GaussianPathGenerator_next,args, kwargs)
        if val: val = SamplePathPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C GaussianPathGenerator instance at %s>" % (self.this,)
class GaussianPathGeneratorPtr(GaussianPathGenerator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = GaussianPathGenerator



class MultiPath:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_MultiPath(self)
    def assetNumber(*args, **kwargs):
        val = apply(QuantLibc.MultiPath_assetNumber,args, kwargs)
        return val
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.MultiPath___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.MultiPath___getitem__,args, kwargs)
        if val: val = PathPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C MultiPath instance at %s>" % (self.this,)
class MultiPathPtr(MultiPath):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = MultiPath



class SampleMultiPath:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SampleMultiPath(self)
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __setmethods__.update({
        "value" : QuantLibc.SampleMultiPath_value_set,
        "weight" : QuantLibc.SampleMultiPath_weight_set,
    })
    def __setattr__(self,name,value):
        if (name == "this") or (name == "thisown"): self.__dict__[name] = value; return
        method = SampleMultiPath.__setmethods__.get(name,None)
        if method: return method(self,value)
        self.__dict__[name] = value
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    __getmethods__.update({
        "value" : lambda x : MultiPathPtr(QuantLibc.SampleMultiPath_value_get(x)),
        "weight" : QuantLibc.SampleMultiPath_weight_get,
    })
    def __getattr__(self,name):
        method = SampleMultiPath.__getmethods__.get(name,None)
        if method: return method(self)
        raise AttributeError,name
    def __repr__(self):
        return "<C SampleMultiPath instance at %s>" % (self.this,)
class SampleMultiPathPtr(SampleMultiPath):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SampleMultiPath



class GaussianMultiPathGenerator:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_GaussianMultiPathGenerator,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_GaussianMultiPathGenerator(self)
    def next(*args, **kwargs):
        val = apply(QuantLibc.GaussianMultiPathGenerator_next,args, kwargs)
        if val: val = SampleMultiPathPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C GaussianMultiPathGenerator instance at %s>" % (self.this,)
class GaussianMultiPathGeneratorPtr(GaussianMultiPathGenerator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = GaussianMultiPathGenerator



class TridiagonalOperator:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_TridiagonalOperator,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_TridiagonalOperator(self)
    def solveFor(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_solveFor,args, kwargs)
        if val: val = ArrayPtr(val) ; val.thisown = 1
        return val
    def applyTo(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_applyTo,args, kwargs)
        if val: val = ArrayPtr(val) ; val.thisown = 1
        return val
    def size(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_size,args, kwargs)
        return val
    def setLowerBC(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_setLowerBC,args, kwargs)
        return val
    def setUpperBC(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_setUpperBC,args, kwargs)
        return val
    def setFirstRow(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_setFirstRow,args, kwargs)
        return val
    def setMidRow(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_setMidRow,args, kwargs)
        return val
    def setMidRows(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_setMidRows,args, kwargs)
        return val
    def setLastRow(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator_setLastRow,args, kwargs)
        return val
    def __add__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___add__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __sub__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___sub__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __mul__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___mul__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __div__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___div__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __iadd__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___iadd__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __isub__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___isub__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __imul__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___imul__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __rmul__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___rmul__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    def __idiv__(*args, **kwargs):
        val = apply(QuantLibc.TridiagonalOperator___idiv__,args, kwargs)
        if val: val = TridiagonalOperatorPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C TridiagonalOperator instance at %s>" % (self.this,)
class TridiagonalOperatorPtr(TridiagonalOperator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = TridiagonalOperator



class Identity(TridiagonalOperator):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Identity,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_TridiagonalIdentity(self)
    __setmethods__ = {}
    for _s in [TridiagonalOperator]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TridiagonalOperator]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Identity instance at %s>" % (self.this,)
class IdentityPtr(Identity):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Identity



class DPlus(TridiagonalOperator):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DPlus,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DPlus(self)
    __setmethods__ = {}
    for _s in [TridiagonalOperator]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TridiagonalOperator]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DPlus instance at %s>" % (self.this,)
class DPlusPtr(DPlus):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DPlus



class DMinus(TridiagonalOperator):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DMinus,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DMinus(self)
    __setmethods__ = {}
    for _s in [TridiagonalOperator]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TridiagonalOperator]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DMinus instance at %s>" % (self.this,)
class DMinusPtr(DMinus):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DMinus



class DZero(TridiagonalOperator):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DZero,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DZero(self)
    __setmethods__ = {}
    for _s in [TridiagonalOperator]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TridiagonalOperator]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DZero instance at %s>" % (self.this,)
class DZeroPtr(DZero):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DZero



class DPlusDMinus(TridiagonalOperator):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DPlusDMinus,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DPlusDMinus(self)
    __setmethods__ = {}
    for _s in [TridiagonalOperator]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TridiagonalOperator]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DPlusDMinus instance at %s>" % (self.this,)
class DPlusDMinusPtr(DPlusDMinus):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DPlusDMinus



class RateHelper:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_RateHelperHandle(self)
    def maturity(*args, **kwargs):
        val = apply(QuantLibc.RateHelper_maturity,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C RateHelper instance at %s>" % (self.this,)
class RateHelperPtr(RateHelper):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = RateHelper



class DepositRateHelper(RateHelper):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DepositRateHelper,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DepositRateHelperHandle(self)
    __setmethods__ = {}
    for _s in [RateHelper]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [RateHelper]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DepositRateHelper instance at %s>" % (self.this,)
class DepositRateHelperPtr(DepositRateHelper):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DepositRateHelper



class FraRateHelper(RateHelper):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FraRateHelper,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FraRateHelperHandle(self)
    __setmethods__ = {}
    for _s in [RateHelper]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [RateHelper]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FraRateHelper instance at %s>" % (self.this,)
class FraRateHelperPtr(FraRateHelper):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FraRateHelper



class FuturesRateHelper(RateHelper):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FuturesRateHelper,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FuturesRateHelperHandle(self)
    __setmethods__ = {}
    for _s in [RateHelper]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [RateHelper]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FuturesRateHelper instance at %s>" % (self.this,)
class FuturesRateHelperPtr(FuturesRateHelper):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FuturesRateHelper



class SwapRateHelper(RateHelper):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SwapRateHelper,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SwapRateHelperHandle(self)
    __setmethods__ = {}
    for _s in [RateHelper]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [RateHelper]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SwapRateHelper instance at %s>" % (self.this,)
class SwapRateHelperPtr(SwapRateHelper):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SwapRateHelper



class RateHelperVector:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_RateHelperVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_RateHelperHandleVector(self)
    def __len__(*args, **kwargs):
        val = apply(QuantLibc.RateHelperVector___len__,args, kwargs)
        return val
    def __getitem__(*args, **kwargs):
        val = apply(QuantLibc.RateHelperVector___getitem__,args, kwargs)
        if val: val = RateHelperPtr(val) ; val.thisown = 1
        return val
    def __setitem__(*args, **kwargs):
        val = apply(QuantLibc.RateHelperVector___setitem__,args, kwargs)
        return val
    def __getslice__(*args, **kwargs):
        val = apply(QuantLibc.RateHelperVector___getslice__,args, kwargs)
        if val: val = RateHelperVectorPtr(val) ; val.thisown = 1
        return val
    def __setslice__(*args, **kwargs):
        val = apply(QuantLibc.RateHelperVector___setslice__,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.RateHelperVector___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C RateHelperVector instance at %s>" % (self.this,)
class RateHelperVectorPtr(RateHelperVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = RateHelperVector



class PiecewiseFlatForward(TermStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_PiecewiseFlatForward,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_PiecewiseFlatForwardHandle(self)
    def dates(*args, **kwargs):
        val = apply(QuantLibc.PiecewiseFlatForward_dates,args, kwargs)
        if val: val = DateVectorPtr(val) 
        return val
    def times(*args, **kwargs):
        val = apply(QuantLibc.PiecewiseFlatForward_times,args, kwargs)
        if val: val = DoubleVectorPtr(val) 
        return val
    __setmethods__ = {}
    for _s in [TermStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [TermStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C PiecewiseFlatForward instance at %s>" % (self.this,)
class PiecewiseFlatForwardPtr(PiecewiseFlatForward):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = PiecewiseFlatForward



class EuropeanOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_EuropeanOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_EuropeanOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.EuropeanOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C EuropeanOption instance at %s>" % (self.this,)
class EuropeanOptionPtr(EuropeanOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = EuropeanOption



class CliquetOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CliquetOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CliquetOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.CliquetOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CliquetOption instance at %s>" % (self.this,)
class CliquetOptionPtr(CliquetOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CliquetOption



class BinaryOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BinaryOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BinaryOption(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_value,args, kwargs)
        return val
    def delta(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_dividendRho,args, kwargs)
        return val
    def impliedVolatility(*args, **kwargs):
        val = apply(QuantLibc.BinaryOption_impliedVolatility,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BinaryOption instance at %s>" % (self.this,)
class BinaryOptionPtr(BinaryOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BinaryOption



class BarrierOption:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_BarrierOption,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_BarrierOption(self)
    def delta(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_delta,args, kwargs)
        return val
    def gamma(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_gamma,args, kwargs)
        return val
    def theta(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_theta,args, kwargs)
        return val
    def vega(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_vega,args, kwargs)
        return val
    def rho(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_rho,args, kwargs)
        return val
    def dividendRho(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_dividendRho,args, kwargs)
        return val
    def value(*args, **kwargs):
        val = apply(QuantLibc.BarrierOption_value,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C BarrierOption instance at %s>" % (self.this,)
class BarrierOptionPtr(BarrierOption):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = BarrierOption



class ContinuousGeometricAPO:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_ContinuousGeometricAPO,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_ContinuousGeometricAPO(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.ContinuousGeometricAPO_value,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C ContinuousGeometricAPO instance at %s>" % (self.this,)
class ContinuousGeometricAPOPtr(ContinuousGeometricAPO):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = ContinuousGeometricAPO



class DiscreteGeometricAPO:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DiscreteGeometricAPO,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DiscreteGeometricAPO(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.DiscreteGeometricAPO_value,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DiscreteGeometricAPO instance at %s>" % (self.this,)
class DiscreteGeometricAPOPtr(DiscreteGeometricAPO):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DiscreteGeometricAPO



class DiscreteGeometricASO:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_DiscreteGeometricASO,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_DiscreteGeometricASO(self)
    def value(*args, **kwargs):
        val = apply(QuantLibc.DiscreteGeometricASO_value,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C DiscreteGeometricASO instance at %s>" % (self.this,)
class DiscreteGeometricASOPtr(DiscreteGeometricASO):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = DiscreteGeometricASO



class SampleNumber:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SampleNumber(self)
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __setmethods__.update({
        "value" : QuantLibc.SampleNumber_value_set,
        "weight" : QuantLibc.SampleNumber_weight_set,
    })
    def __setattr__(self,name,value):
        if (name == "this") or (name == "thisown"): self.__dict__[name] = value; return
        method = SampleNumber.__setmethods__.get(name,None)
        if method: return method(self,value)
        self.__dict__[name] = value
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    __getmethods__.update({
        "value" : QuantLibc.SampleNumber_value_get,
        "weight" : QuantLibc.SampleNumber_weight_get,
    })
    def __getattr__(self,name):
        method = SampleNumber.__getmethods__.get(name,None)
        if method: return method(self)
        raise AttributeError,name
    def __repr__(self):
        return "<C SampleNumber instance at %s>" % (self.this,)
class SampleNumberPtr(SampleNumber):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SampleNumber



class UniformRandomGenerator:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_UniformRandomGenerator,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_UniformRandomGenerator(self)
    def next(*args, **kwargs):
        val = apply(QuantLibc.UniformRandomGenerator_next,args, kwargs)
        if val: val = SampleNumberPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C UniformRandomGenerator instance at %s>" % (self.this,)
class UniformRandomGeneratorPtr(UniformRandomGenerator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = UniformRandomGenerator



class GaussianRandomGenerator:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_GaussianRandomGenerator,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_GaussianRandomGenerator(self)
    def next(*args, **kwargs):
        val = apply(QuantLibc.GaussianRandomGenerator_next,args, kwargs)
        if val: val = SampleNumberPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C GaussianRandomGenerator instance at %s>" % (self.this,)
class GaussianRandomGeneratorPtr(GaussianRandomGenerator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = GaussianRandomGenerator



class LecuyerUniformRng:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_LecuyerUniformRng,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_LecuyerUniformRng(self)
    def next(*args, **kwargs):
        val = apply(QuantLibc.LecuyerUniformRng_next,args, kwargs)
        if val: val = SampleNumberPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C LecuyerUniformRng instance at %s>" % (self.this,)
class LecuyerUniformRngPtr(LecuyerUniformRng):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = LecuyerUniformRng



class KnuthUniformRng:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_KnuthUniformRng,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_KnuthUniformRng(self)
    def next(*args, **kwargs):
        val = apply(QuantLibc.KnuthUniformRng_next,args, kwargs)
        if val: val = SampleNumberPtr(val) ; val.thisown = 1
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C KnuthUniformRng instance at %s>" % (self.this,)
class KnuthUniformRngPtr(KnuthUniformRng):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = KnuthUniformRng



class RiskMeasures:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_RiskMeasures,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_RiskMeasures(self)
    def potentialUpside(*args, **kwargs):
        val = apply(QuantLibc.RiskMeasures_potentialUpside,args, kwargs)
        return val
    def valueAtRisk(*args, **kwargs):
        val = apply(QuantLibc.RiskMeasures_valueAtRisk,args, kwargs)
        return val
    def shortfall(*args, **kwargs):
        val = apply(QuantLibc.RiskMeasures_shortfall,args, kwargs)
        return val
    def averageShortfall(*args, **kwargs):
        val = apply(QuantLibc.RiskMeasures_averageShortfall,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C RiskMeasures instance at %s>" % (self.this,)
class RiskMeasuresPtr(RiskMeasures):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = RiskMeasures



class RiskStatistics:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_RiskStatistics,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_RiskStatistics(self)
    def samples(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_samples,args, kwargs)
        return val
    def weightSum(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_weightSum,args, kwargs)
        return val
    def mean(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_mean,args, kwargs)
        return val
    def variance(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_variance,args, kwargs)
        return val
    def standardDeviation(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_standardDeviation,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_errorEstimate,args, kwargs)
        return val
    def skewness(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_skewness,args, kwargs)
        return val
    def kurtosis(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_kurtosis,args, kwargs)
        return val
    def min(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_min,args, kwargs)
        return val
    def max(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_max,args, kwargs)
        return val
    def potentialUpside(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_potentialUpside,args, kwargs)
        return val
    def valueAtRisk(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_valueAtRisk,args, kwargs)
        return val
    def expectedShortfall(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_expectedShortfall,args, kwargs)
        return val
    def shortfall(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_shortfall,args, kwargs)
        return val
    def averageShortfall(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_averageShortfall,args, kwargs)
        return val
    def add(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_add,args, kwargs)
        return val
    def reset(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_reset,args, kwargs)
        return val
    def addSequence(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_addSequence,args, kwargs)
        return val
    def addWeightedSequence(*args, **kwargs):
        val = apply(QuantLibc.RiskStatistics_addWeightedSequence,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C RiskStatistics instance at %s>" % (self.this,)
class RiskStatisticsPtr(RiskStatistics):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = RiskStatistics



class Scheduler:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Scheduler,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Scheduler(self)
    def size(*args, **kwargs):
        val = apply(QuantLibc.Scheduler_size,args, kwargs)
        return val
    def date(*args, **kwargs):
        val = apply(QuantLibc.Scheduler_date,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def isRegular(*args, **kwargs):
        val = apply(QuantLibc.Scheduler_isRegular,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Scheduler instance at %s>" % (self.this,)
class SchedulerPtr(Scheduler):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Scheduler



class Solver1D:
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Solver1D(self)
    def setMaxEvaluations(*args, **kwargs):
        val = apply(QuantLibc.Solver1D_setMaxEvaluations,args, kwargs)
        return val
    def setLowBound(*args, **kwargs):
        val = apply(QuantLibc.Solver1D_setLowBound,args, kwargs)
        return val
    def setHiBound(*args, **kwargs):
        val = apply(QuantLibc.Solver1D_setHiBound,args, kwargs)
        return val
    def solve(*args, **kwargs):
        val = apply(QuantLibc.Solver1D_solve,args, kwargs)
        return val
    def bracketedSolve(*args, **kwargs):
        val = apply(QuantLibc.Solver1D_bracketedSolve,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Solver1D instance at %s>" % (self.this,)
class Solver1DPtr(Solver1D):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Solver1D



class Brent(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Brent,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Brent(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Brent instance at %s>" % (self.this,)
class BrentPtr(Brent):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Brent



class Bisection(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Bisection,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Bisection(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Bisection instance at %s>" % (self.this,)
class BisectionPtr(Bisection):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Bisection



class FalsePosition(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_FalsePosition,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_FalsePosition(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C FalsePosition instance at %s>" % (self.this,)
class FalsePositionPtr(FalsePosition):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = FalsePosition



class Newton(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Newton,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Newton(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Newton instance at %s>" % (self.this,)
class NewtonPtr(Newton):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Newton



class NewtonSafe(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_NewtonSafe,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_NewtonSafe(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C NewtonSafe instance at %s>" % (self.this,)
class NewtonSafePtr(NewtonSafe):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = NewtonSafe



class Ridder(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Ridder,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Ridder(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Ridder instance at %s>" % (self.this,)
class RidderPtr(Ridder):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Ridder



class Secant(Solver1D):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Secant,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Secant(self)
    __setmethods__ = {}
    for _s in [Solver1D]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Solver1D]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Secant instance at %s>" % (self.this,)
class SecantPtr(Secant):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Secant



class SegmentIntegral:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SegmentIntegral,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SegmentIntegral(self)
    def __call__(*args, **kwargs):
        val = apply(QuantLibc.SegmentIntegral___call__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SegmentIntegral instance at %s>" % (self.this,)
class SegmentIntegralPtr(SegmentIntegral):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SegmentIntegral



class Statistics:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_Statistics,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_Statistics(self)
    def samples(*args, **kwargs):
        val = apply(QuantLibc.Statistics_samples,args, kwargs)
        return val
    def weightSum(*args, **kwargs):
        val = apply(QuantLibc.Statistics_weightSum,args, kwargs)
        return val
    def mean(*args, **kwargs):
        val = apply(QuantLibc.Statistics_mean,args, kwargs)
        return val
    def variance(*args, **kwargs):
        val = apply(QuantLibc.Statistics_variance,args, kwargs)
        return val
    def standardDeviation(*args, **kwargs):
        val = apply(QuantLibc.Statistics_standardDeviation,args, kwargs)
        return val
    def downsideVariance(*args, **kwargs):
        val = apply(QuantLibc.Statistics_downsideVariance,args, kwargs)
        return val
    def downsideDeviation(*args, **kwargs):
        val = apply(QuantLibc.Statistics_downsideDeviation,args, kwargs)
        return val
    def errorEstimate(*args, **kwargs):
        val = apply(QuantLibc.Statistics_errorEstimate,args, kwargs)
        return val
    def skewness(*args, **kwargs):
        val = apply(QuantLibc.Statistics_skewness,args, kwargs)
        return val
    def kurtosis(*args, **kwargs):
        val = apply(QuantLibc.Statistics_kurtosis,args, kwargs)
        return val
    def min(*args, **kwargs):
        val = apply(QuantLibc.Statistics_min,args, kwargs)
        return val
    def max(*args, **kwargs):
        val = apply(QuantLibc.Statistics_max,args, kwargs)
        return val
    def add(*args, **kwargs):
        val = apply(QuantLibc.Statistics_add,args, kwargs)
        return val
    def reset(*args, **kwargs):
        val = apply(QuantLibc.Statistics_reset,args, kwargs)
        return val
    def addSequence(*args, **kwargs):
        val = apply(QuantLibc.Statistics_addSequence,args, kwargs)
        return val
    def addWeightedSequence(*args, **kwargs):
        val = apply(QuantLibc.Statistics_addWeightedSequence,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C Statistics instance at %s>" % (self.this,)
class StatisticsPtr(Statistics):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = Statistics



class MultivariateAccumulator:
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_MultivariateAccumulator,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_MultivariateAccumulator(self)
    def size(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_size,args, kwargs)
        return val
    def samples(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_samples,args, kwargs)
        return val
    def weightSum(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_weightSum,args, kwargs)
        return val
    def mean(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_mean,args, kwargs)
        if val: val = ArrayPtr(val) ; val.thisown = 1
        return val
    def covariance(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_covariance,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def correlation(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_correlation,args, kwargs)
        if val: val = MatrixPtr(val) ; val.thisown = 1
        return val
    def add(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_add,args, kwargs)
        return val
    def reset(*args, **kwargs):
        val = apply(QuantLibc.MultivariateAccumulator_reset,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in []: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in []: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C MultivariateAccumulator instance at %s>" % (self.this,)
class MultivariateAccumulatorPtr(MultivariateAccumulator):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = MultivariateAccumulator



class SwaptionVolatilityStructure(Observable):
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SwaptionVolatilityStructureHandle(self)
    def todaysDate(*args, **kwargs):
        val = apply(QuantLibc.SwaptionVolatilityStructure_todaysDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def _volatilityVsDate(*args, **kwargs):
        val = apply(QuantLibc.SwaptionVolatilityStructure__volatilityVsDate,args, kwargs)
        return val
    def _volatilityVsTime(*args, **kwargs):
        val = apply(QuantLibc.SwaptionVolatilityStructure__volatilityVsTime,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.SwaptionVolatilityStructure___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SwaptionVolatilityStructure instance at %s>" % (self.this,)
class SwaptionVolatilityStructurePtr(SwaptionVolatilityStructure):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SwaptionVolatilityStructure



class SwaptionVolatilityStructureHandle(Observable):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SwaptionVolatilityStructureHandle,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SwaptionVolatilityStructureRelinkableHandle(self)
    def linkTo(*args, **kwargs):
        val = apply(QuantLibc.SwaptionVolatilityStructureHandle_linkTo,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.SwaptionVolatilityStructureHandle___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SwaptionVolatilityStructureHandle instance at %s>" % (self.this,)
class SwaptionVolatilityStructureHandlePtr(SwaptionVolatilityStructureHandle):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SwaptionVolatilityStructureHandle



class CapFlatVolatilityStructure(Observable):
    def __init__(self,this):
        self.this = this

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CapFlatVolatilityStructureHandle(self)
    def todaysDate(*args, **kwargs):
        val = apply(QuantLibc.CapFlatVolatilityStructure_todaysDate,args, kwargs)
        if val: val = DatePtr(val) ; val.thisown = 1
        return val
    def _volatilityVsDate(*args, **kwargs):
        val = apply(QuantLibc.CapFlatVolatilityStructure__volatilityVsDate,args, kwargs)
        return val
    def _volatilityVsTime(*args, **kwargs):
        val = apply(QuantLibc.CapFlatVolatilityStructure__volatilityVsTime,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.CapFlatVolatilityStructure___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CapFlatVolatilityStructure instance at %s>" % (self.this,)
class CapFlatVolatilityStructurePtr(CapFlatVolatilityStructure):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CapFlatVolatilityStructure



class CapFlatVolatilityStructureHandle(Observable):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CapFlatVolatilityStructureHandle,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CapFlatVolatilityStructureRelinkableHandle(self)
    def linkTo(*args, **kwargs):
        val = apply(QuantLibc.CapFlatVolatilityStructureHandle_linkTo,args, kwargs)
        return val
    def __nonzero__(*args, **kwargs):
        val = apply(QuantLibc.CapFlatVolatilityStructureHandle___nonzero__,args, kwargs)
        return val
    __setmethods__ = {}
    for _s in [Observable]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [Observable]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CapFlatVolatilityStructureHandle instance at %s>" % (self.this,)
class CapFlatVolatilityStructureHandlePtr(CapFlatVolatilityStructureHandle):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CapFlatVolatilityStructureHandle



class SwaptionVolatilityMatrix(SwaptionVolatilityStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_SwaptionVolatilityMatrix,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_SwaptionVolatilityMatrixHandle(self)
    __setmethods__ = {}
    for _s in [SwaptionVolatilityStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [SwaptionVolatilityStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C SwaptionVolatilityMatrix instance at %s>" % (self.this,)
class SwaptionVolatilityMatrixPtr(SwaptionVolatilityMatrix):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = SwaptionVolatilityMatrix



class CapFlatVolatilityVector(CapFlatVolatilityStructure):
    def __init__(self,*args,**kwargs):
        self.this = apply(QuantLibc.new_CapFlatVolatilityVector,args,kwargs)
        self.thisown = 1

    def __del__(self,QuantLibc=QuantLibc):
        if getattr(self,'thisown',0):
            QuantLibc.delete_CapFlatVolatilityVectorHandle(self)
    __setmethods__ = {}
    for _s in [CapFlatVolatilityStructure]: __setmethods__.update(_s.__setmethods__)
    __getmethods__ = {}
    for _s in [CapFlatVolatilityStructure]: __getmethods__.update(_s.__getmethods__)
    def __repr__(self):
        return "<C CapFlatVolatilityVector instance at %s>" % (self.this,)
class CapFlatVolatilityVectorPtr(CapFlatVolatilityVector):
    def __init__(self,this):
        self.this = this
        self.thisown = 0
        self.__class__ = CapFlatVolatilityVector





#-------------- FUNCTION WRAPPERS ------------------

Date_isLeap = QuantLibc.Date_isLeap

def Date_minDate(*args, **kwargs):
    val = apply(QuantLibc.Date_minDate,args,kwargs)
    if val: val = DatePtr(val); val.thisown = 1
    return val

def Date_maxDate(*args, **kwargs):
    val = apply(QuantLibc.Date_maxDate,args,kwargs)
    if val: val = DatePtr(val); val.thisown = 1
    return val

def DateFromSerialNumber(*args, **kwargs):
    val = apply(QuantLibc.DateFromSerialNumber,args,kwargs)
    if val: val = DatePtr(val); val.thisown = 1
    return val

def Euribor(*args, **kwargs):
    val = apply(QuantLibc.Euribor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def AUDLibor(*args, **kwargs):
    val = apply(QuantLibc.AUDLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def GBPLibor(*args, **kwargs):
    val = apply(QuantLibc.GBPLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def USDLibor(*args, **kwargs):
    val = apply(QuantLibc.USDLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def JPYLibor(*args, **kwargs):
    val = apply(QuantLibc.JPYLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def CADLibor(*args, **kwargs):
    val = apply(QuantLibc.CADLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def CHFLibor(*args, **kwargs):
    val = apply(QuantLibc.CHFLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def ZARLibor(*args, **kwargs):
    val = apply(QuantLibc.ZARLibor,args,kwargs)
    if val: val = XiborPtr(val); val.thisown = 1
    return val

def transpose(*args, **kwargs):
    val = apply(QuantLibc.transpose,args,kwargs)
    if val: val = MatrixPtr(val); val.thisown = 1
    return val

def outerProduct(*args, **kwargs):
    val = apply(QuantLibc.outerProduct,args,kwargs)
    if val: val = MatrixPtr(val); val.thisown = 1
    return val

def matrixProduct(*args, **kwargs):
    val = apply(QuantLibc.matrixProduct,args,kwargs)
    if val: val = MatrixPtr(val); val.thisown = 1
    return val

def matrixSqrt(*args, **kwargs):
    val = apply(QuantLibc.matrixSqrt,args,kwargs)
    if val: val = MatrixPtr(val); val.thisown = 1
    return val

def getCovariance(*args, **kwargs):
    val = apply(QuantLibc.getCovariance,args,kwargs)
    if val: val = MatrixPtr(val); val.thisown = 1
    return val

valueAtCenter = QuantLibc.valueAtCenter

firstDerivativeAtCenter = QuantLibc.firstDerivativeAtCenter

secondDerivativeAtCenter = QuantLibc.secondDerivativeAtCenter

def SymmetricEigenvalues(*args, **kwargs):
    val = apply(QuantLibc.SymmetricEigenvalues,args,kwargs)
    if val: val = ArrayPtr(val); val.thisown = 1
    return val

def SymmetricEigenvectors(*args, **kwargs):
    val = apply(QuantLibc.SymmetricEigenvectors,args,kwargs)
    if val: val = MatrixPtr(val); val.thisown = 1
    return val



#-------------- VARIABLE WRAPPERS ------------------

cvar = QuantLibc.cvar
XiborManager = XiborManagerClassPtr(QuantLibc.cvar.XiborManager)