make Inflation and Vol term structures inherit from TermStructure

Author: thrasibule

quantlib/termstructure.pyx

@@ -2,6 +2,7 @@ from quantlib.ext cimport static_pointer_cast
 from quantlib.time.date cimport Date, date_from_qldate
 from quantlib.time._date cimport Date as QlDate
 from quantlib.time.daycounter cimport DayCounter
+from quantlib.time.calendar cimport Calendar
 cimport quantlib.time._daycounter as _dc
 
 cdef class TermStructure(Observable):
@@ -18,20 +19,24 @@ cdef class TermStructure(Observable):
         return static_pointer_cast[QlObservable](self._thisptr)
 
     def time_from_reference(self, Date dt):
+        """date/time conversion"""
         return self.as_ptr().timeFromReference(dt._thisptr)
 
     @property
     def reference_date(self):
+        """ the date at which discount = 1.0 and/or variance = 0.0"""
         cdef QlDate ref_date = self.as_ptr().referenceDate()
         return date_from_qldate(ref_date)
 
     @property
     def max_date(self):
+        """the latest date for which the curve can return values"""
         cdef QlDate max_date = self.as_ptr().maxDate()
         return date_from_qldate(max_date)
 
     @property
     def max_time(self):
+        """the latest time for which the curve can return values"""
         return self.as_ptr().maxTime()
 
     @property
@@ -42,4 +47,11 @@ cdef class TermStructure(Observable):
 
     @property
     def settlement_days(self):
+        """ number of settlement days used for reference date calculation"""
         return self.as_ptr().settlementDays()
+
+    @property
+    def calendar(self):
+        cdef Calendar instance = Calendar.__new__(Calendar)
+        instance._thisptr = self.as_ptr().calendar()
+        return instance

quantlib/termstructures/_inflation_term_structure.pxd

@@ -12,52 +12,36 @@ include '../types.pxi'
 from libcpp cimport bool
 
 from quantlib.ext cimport shared_ptr
-from quantlib.handle cimport Handle
 from quantlib.time._date cimport Date
 from quantlib.time._calendar cimport Calendar
 from quantlib.time._daycounter cimport DayCounter
 from quantlib.time._period cimport Period, Frequency
-from quantlib.termstructures._yield_term_structure cimport YieldTermStructure
 from quantlib.termstructures.inflation._seasonality cimport Seasonality
-
+from .._termstructure cimport TermStructure
 
 cdef extern from 'ql/termstructures/inflationtermstructure.hpp' namespace 'QuantLib' nogil:
 
-    cdef cppclass InflationTermStructure:
-
-        InflationTermStructure() except +
-        Date& referenceDate()
-        Date& maxDate()
-        Date& baseDate()
-        Rate baseRate()
-
+    cdef cppclass InflationTermStructure(TermStructure):
+        Date baseDate()
+        Real baseRate()
 
     cdef cppclass ZeroInflationTermStructure(InflationTermStructure):
-
-        ZeroInflationTermStructure() except +
-        ZeroInflationTermStructure(DayCounter& dayCounter,
-                                   Rate baseZeroRate,
-                                   Period& lag,
+        ZeroInflationTermStructure(Date baseDate,
                                    Frequency frequency,
-                                   const Handle[YieldTermStructure]& yTS,
+                                   DayCounter& dayCounter,
                                    const shared_ptr[Seasonality]& seasonality # = shared_ptr<Seasonality>()
         ) except +
         ZeroInflationTermStructure(const Date& referenceDate,
-                                   const Calendar& calendar,
-                                   const DayCounter& dayCounter,
-                                   Rate baseZeroRate,
-                                   const Period& lag,
+                                   Date baseDate,
                                    Frequency frequency,
-                                   const Handle[YieldTermStructure]& yTS,
+                                   const DayCounter& dayCounter,
                                    const shared_ptr[Seasonality] &seasonality # = shared_ptr<Seasonality>())
         ) except +
         ZeroInflationTermStructure(Natural settlementDays,
                                    const Calendar& calendar,
-                                   const DayCounter& dayCounter,
-                                   Rate baseZeroRate,
-                                   const Period& lag,
+                                   Date baseDate,
                                    Frequency frequency,
-                                   const Handle[YieldTermStructure]& yTS,
+                                   const DayCounter& dayCounter,
                                    const shared_ptr[Seasonality] &seasonality # = boost::shared_ptr<Seasonality>()
         ) except +
 
@@ -71,15 +55,23 @@ cdef extern from 'ql/termstructures/inflationtermstructure.hpp' namespace 'Quant
 
 
     cdef cppclass YoYInflationTermStructure(InflationTermStructure):
-
-        YoYInflationTermStructure() except +
-
         YoYInflationTermStructure(DayCounter& dayCounter,
-                                  Rate baseZeroRate,
-                                  Period& lag,
+                                  Rate baseYoYRate,
+                                  Frequency frequency,
+                                  const DayCounter& dayCounter,
+                                  const shared_ptr[Seasonality]& seasonality) except +
+        YoYInflationTermStructure(Date& referenceDate,
+                                  Date baseDate,
+                                  Rate baseYoYRate,
+                                  Frequency frequency,
+                                  const DayCounter& dayCounter,
+                                  const shared_ptr[Seasonality]& seasonality) except +
+        YoYInflationTermStructure(Natural settlmentDays,
+                                  const Calendar& calendar,
+                                  Date baseDate,
+                                  Rate baseYoYRate,
                                   Frequency frequency,
-                                  bool indexIsInterpolated,
-                                  const Handle[YieldTermStructure]& yTS,
+                                  const DayCounter& dayCounter,
                                   const shared_ptr[Seasonality]& seasonality) except +
 
         Rate yoyRate(Date& d,

quantlib/termstructures/_vol_term_structure.pxd

@@ -5,9 +5,10 @@ from quantlib.time._calendar cimport Calendar
 from quantlib.time._date cimport Date
 from quantlib.time._period cimport Period
 from quantlib.time.businessdayconvention cimport BusinessDayConvention
+from .._termstructure cimport TermStructure
 
 cdef extern from 'ql/termstructures/voltermstructure.hpp' namespace 'QuantLib' nogil:
-    cdef cppclass VolatilityTermStructure:
+    cdef cppclass VolatilityTermStructure(TermStructure):
         VolatilityTermStructure(BusinessDayConvention bdc,
                                 const DayCounter& dc) # = DayCounter()
         #initialize with a fixed reference date

quantlib/termstructures/inflation/seasonality.pyx

@@ -37,7 +37,8 @@ cdef class Seasonality:
         return self._thisptr.get().correctZeroRate(
             d._thisptr,
             r,
-            deref(iTS._thisptr))
+            deref(<_if.InflationTermStructure*>iTS._thisptr.get())
+        )
 
     def correctYoYRate(self,
 		    Date d,
@@ -47,13 +48,14 @@ cdef class Seasonality:
         return self._thisptr.get().correctYoYRate(
             d._thisptr,
             r,
-            deref(iTS._thisptr))
+            deref(<_if.InflationTermStructure*>iTS._thisptr.get()))
 
     def isConsistent(self,
 		    InflationTermStructure iTS):
 
         return self._thisptr.get().isConsistent(
-            deref(iTS._thisptr))
+        deref(<_if.InflationTermStructure*>iTS._thisptr.get())
+        )
 
 
 cdef class MultiplicativePriceSeasonality(Seasonality):
@@ -94,4 +96,5 @@ cdef class MultiplicativePriceSeasonality(Seasonality):
     def isConsistent(self, InflationTermStructure iTS):
 
         return self._thisptr.get().isConsistent(
-            deref(iTS._thisptr))
+            deref(<_if.InflationTermStructure*>iTS._thisptr.get())
+        )

quantlib/termstructures/inflation_term_structure.pxd

@@ -1,8 +1,7 @@
-cimport quantlib.termstructures._inflation_term_structure as _its
-from quantlib.ext cimport shared_ptr
+from ..termstructure cimport TermStructure
 
-cdef class InflationTermStructure:
-    cdef shared_ptr[_its.InflationTermStructure] _thisptr
+cdef class InflationTermStructure(TermStructure):
+    pass
 
 cdef class ZeroInflationTermStructure(InflationTermStructure):
     pass

quantlib/termstructures/inflation_term_structure.pyx

@@ -14,45 +14,23 @@ from quantlib.time.date cimport Date, Period, date_from_qldate, period_from_qlpe
 
 from libcpp.vector cimport vector
 from cython.operator cimport dereference as deref
-from quantlib.ext cimport static_pointer_cast
 
-cimport quantlib.time._daycounter as _dc
-from quantlib.time.daycounter cimport DayCounter
+from quantlib.time._period cimport Days
 
-from quantlib.time._period cimport Frequency, Days
-from quantlib.time.calendar cimport Calendar
-
-from quantlib.termstructures.yield_term_structure cimport YieldTermStructure
-
-cimport quantlib.termstructures.yields._flat_forward as _ff
-cimport quantlib._interest_rate as _ir
 cimport quantlib.termstructures._inflation_term_structure as _if
-cimport quantlib.termstructures.inflation._seasonality as _se
-
-from quantlib.termstructures.inflation.seasonality cimport Seasonality
 
-cdef class InflationTermStructure:
+cdef class InflationTermStructure(TermStructure):
     """Abstract Base Class.
     """
 
-    property max_date:
-        def __get__(self):
-            cdef _date.Date max_date = self._thisptr.get().maxDate()
-            return date_from_qldate(max_date)
-
-    @property
-    def reference_date(self):
-        cdef _date.Date reference_date = self._thisptr.get().referenceDate()
-        return date_from_qldate(reference_date)
-
     @property
     def base_date(self):
-        cdef _date.Date base_date = self._thisptr.get().baseDate()
+        cdef _date.Date base_date = (<_if.InflationTermStructure*>self._thisptr.get()).baseDate()
         return date_from_qldate(base_date)
 
     @property
     def base_rate(self):
-        return self._thisptr.get().baseRate()
+        return (<_if.InflationTermStructure*>self._thisptr.get()).baseRate()
 
 cdef class ZeroInflationTermStructure(InflationTermStructure):
 

quantlib/termstructures/vol_term_structure.pxd

@@ -1,7 +1,5 @@
-from libcpp cimport bool as cbool
-from quantlib.ext cimport shared_ptr
+from ..termstructure cimport TermStructure
 from . cimport _vol_term_structure as _vts
 
-cdef class VolatilityTermStructure:
-    cdef shared_ptr[_vts.VolatilityTermStructure] _thisptr
-    cdef _vts.VolatilityTermStructure* as_ptr(self) nogil
+cdef class VolatilityTermStructure(TermStructure):
+    cdef _vts.VolatilityTermStructure* as_vol_ts(self) noexcept nogil

quantlib/termstructures/vol_term_structure.pyx

@@ -1,40 +1,21 @@
 from libcpp cimport bool
 from cython.operator cimport dereference as deref
 from quantlib.time.date cimport date_from_qldate
-from quantlib.time.calendar cimport Calendar
-from quantlib.time.date cimport Date, Period
-cimport quantlib.time._calendar as _calendar
+from quantlib.time.date cimport Period
 
-cdef class VolatilityTermStructure:
+cdef class VolatilityTermStructure(TermStructure):
 
-    cdef inline _vts.VolatilityTermStructure* as_ptr(self) nogil:
-        return self._thisptr.get()
-
-    def time_from_reference(self, Date date not None):
-        return self.as_ptr().timeFromReference(date._thisptr)
-
-    @property
-    def reference_date(self):
-        return date_from_qldate(self.as_ptr().referenceDate())
-
-    @property
-    def calendar(self):
-        cdef Calendar instance = Calendar.__new__(Calendar)
-        instance._thisptr = self.as_ptr().calendar()
-        return instance
-
-    @property
-    def settlement_days(self):
-        return self.as_ptr().settlementDays()
+    cdef inline _vts.VolatilityTermStructure* as_vol_ts(self) noexcept nogil:
+        return <_vts.VolatilityTermStructure*>self._thisptr.get()
 
     def option_date_from_tenor(self, Period period not None):
         return date_from_qldate(
-            self.as_ptr().optionDateFromTenor(deref(period._thisptr)))
+            self.as_vol_ts().optionDateFromTenor(deref(period._thisptr)))
 
     @property
     def extrapolation(self):
-        return self.as_ptr().allowsExtrapolation()
+        return self.as_vol_ts().allowsExtrapolation()
 
     @extrapolation.setter
     def extrapolation(self, bool b):
-        self.as_ptr().enableExtrapolation(b)
+        self.as_vol_ts().enableExtrapolation(b)