Work on improving encapsulation of DiscountCurves

Author: domokane

financepy/__init__.template

@@ -1,4 +1,6 @@
-if 1==1:
+use_banner = true
+
+if use_banner:
     cr = "\n"
 
     s = "####################################################################" + cr

financepy/market/curves/discount_curve.py

@@ -33,8 +33,8 @@ class DiscountCurve:
     def __init__(
         self,
         value_dt: Date,
-        df_dates: list,
-        df_values: np.ndarray,
+        df_dates: list = None,
+        df_values: np.ndarray = None,
         interp_type: InterpTypes = InterpTypes.FLAT_FWD_RATES,
     ):
         """Create the discount curve from a vector of times and discount
@@ -46,11 +46,11 @@ def __init__(
         check_argument_types(self.__init__, locals())
 
         # Validate curve
-        if len(df_dates) < 1:
-            raise FinError("Times has zero length")
+        if df_dates is None:
+            df_dates = [value_dt]
 
-        if len(df_dates) != len(df_values):
-            raise FinError("Times and Values are not the same")
+        if df_values is None:
+            df_values = [1.0]
 
         self._times = [0.0]
         self._dfs = [1.0]
@@ -85,6 +85,18 @@ def __init__(
         self._interpolator = Interpolator(self._interp_type)
         self._interpolator.fit(self._times, self._dfs)
 
+    ###############################################################################
+
+    @property
+    def times(self) -> np.ndarray:
+        """Return the internal array of times (in years) from the anchor date."""
+        return self._times.copy()  # return a copy to prevent external modification
+
+    @property
+    def dfs(self) -> np.ndarray:
+        """Return the internal array of discount factors corresponding to times."""
+        return self._dfs.copy()  # return a copy to prevent external modification
+
     ###########################################################################
 
     def _zero_to_df(

financepy/market/curves/discount_curve_flat.py

@@ -26,7 +26,7 @@ class DiscountCurveFlat(DiscountCurve):
     """A very simple discount curve based on a single zero rate with its
     own specified compounding method. Hence, the curve is assumed to be flat.
     It is used for quick and dirty analysis and when limited information is
-    available. It inherits several methods from FinDiscountCurve."""
+    available. It inherits several methods from DiscountCurve."""
 
     ###############################################################################
 
@@ -44,7 +44,7 @@ def __init__(
         As the curve is flat, no interpolation scheme is required.
         """
 
-        #        super().__init__()
+        super().__init__(value_dt)
 
         check_argument_types(self.__init__, locals())
 
@@ -56,25 +56,24 @@ def __init__(
         # This is used by some inherited functions, so we choose the simplest
         self._interp_type = InterpTypes.FLAT_FWD_RATES
 
-        # Need to set up a grid of times and discount factors
+        # Need to set up a 3M grid of times and discount factors
+        # Those beyond 10 years are extrapolated
         years = np.linspace(0.0, 10.0, 41)
         dts = self.value_dt.add_years(years)
 
-        # Set up a grid of times and discount factors for functions
-        self._dfs = self.df(dts)
+        # Set up a grid of dc adjusted times and discount factors for functions
         self._times = times_from_dates(dts, self.value_dt, dc_type)
+        self._dfs = self.df(dts)
 
     ###############################################################################
 
-    def bump(self, bump_size: float):
-        """Create a new FinDiscountCurveFlat object with the entire curve
-        bumped up by the bumpsize. All other parameters are preserved."""
+    def times(self) -> np.ndarray:
+        """Return the cached grid of times."""
+        return self._times
 
-        rate_bumped = self.flat_rate + bump_size
-        disc_curve = DiscountCurveFlat(
-            self.value_dt, rate_bumped, freq_type=self.freq_type, dc_type=self.dc_type
-        )
-        return disc_curve
+    def dfs(self) -> np.ndarray:
+        """Return the cached grid of discount factors."""
+        return self._dfs
 
     ###############################################################################
 
@@ -99,6 +98,18 @@ def df(self, dts: Union[Date, list]):
 
     ###############################################################################
 
+    def bump(self, bump_size: float):
+        """Create a new FinDiscountCurveFlat object with the entire curve
+        bumped up by the bumpsize. All other parameters are preserved."""
+
+        rate_bumped = self.flat_rate + bump_size
+        disc_curve = DiscountCurveFlat(
+            self.value_dt, rate_bumped, freq_type=self.freq_type, dc_type=self.dc_type
+        )
+        return disc_curve
+
+    ###############################################################################
+
     def __repr__(self):
         s = label_to_string("OBJECT TYPE", type(self).__name__)
         s += label_to_string("VALUE DATE", (self.value_dt))

financepy/market/curves/discount_curve_ns.py

@@ -25,7 +25,7 @@ class DiscountCurveNS(DiscountCurve):
     The internal rate is a continuously compounded rate but you can calculate
     alternative frequencies by providing a corresponding compounding frequency.
     A day count convention is needed to ensure that dates are converted to the
-    correct time in years. The class inherits methods from FinDiscountCurve."""
+    correct time in years. The class inherits methods from DiscountCurve."""
 
     def __init__(
         self,
@@ -64,7 +64,7 @@ def zero_rate(
         dc_type: DayCountTypes = DayCountTypes.ACT_360,
     ):
         """Calculation of zero rates with specified frequency according to
-        NS parametrisation. This method overrides that in FinDiscountCurve.
+        NS parametrisation. This method overrides that in DiscountCurve.
         The parametrisation is not strictly in terms of continuously compounded
         zero rates, this function allows other compounding and day counts.
         This function returns a single or vector of zero rates given a vector

financepy/market/curves/discount_curve_nss.py

@@ -25,7 +25,7 @@ class DiscountCurveNSS(DiscountCurve):
     zero rate curve. The zero rate is assumed to be continuously compounded.
     This can be changed when calling for zero rates. A day count convention is
     needed to ensure that dates are converted to the correct time in years. The
-    class inherits methods from FinDiscountCurve."""
+    class inherits methods from DiscountCurve."""
 
     def __init__(
         self,
@@ -71,7 +71,7 @@ def zero_rate(
         dc_type: DayCountTypes = DayCountTypes.ACT_360,
     ):
         """Calculation of zero rates with specified frequency according to
-        NSS parametrisation. This method overrides that in FinDiscountCurve.
+        NSS parametrisation. This method overrides that in DiscountCurve.
         The NSS parametrisation is no strictly terms of continuously compounded
         zero rates, this function allows other compounding and day counts.
         This function returns a single or vector of zero rates given a vector

financepy/market/curves/discount_curve_poly.py

@@ -25,7 +25,7 @@ class DiscountCurvePoly(DiscountCurve):
     polynomial. The zero rate is assumed to be continuously compounded but
     this can be amended by providing a frequency when extracting zero rates.
     We also need to specify a Day count convention for time calculations.
-    The class inherits all of the methods from FinDiscountCurve."""
+    The class inherits all of the methods from DiscountCurve."""
 
     def __init__(
         self,
@@ -55,7 +55,7 @@ def zero_rate(
         dc_type: DayCountTypes = DayCountTypes.ACT_360,
     ):
         """Calculation of zero rates with specified frequency according to
-        polynomial parametrisation. This method overrides FinDiscountCurve.
+        polynomial parametrisation. This method overrides DiscountCurve.
         The parametrisation is not strictly in terms of continuously compounded
         zero rates, this function allows other compounding and day counts.
         This function returns a single or vector of zero rates given a vector

financepy/market/curves/discount_curve_pwf.py

@@ -24,7 +24,7 @@
 class DiscountCurvePWF(DiscountCurve):
     """Curve is made up of a series of zero rates sections with each having
     a piecewise flat zero rate. The default compounding assumption is
-    continuous. The class inherits methods from FinDiscountCurve."""
+    continuous. The class inherits methods from DiscountCurve."""
 
     def __init__(
         self,
@@ -54,9 +54,9 @@ def __init__(
 
         dc_times = times_from_dates(zero_dts, self.value_dt, self.dc_type)
 
-        self.times = np.array(dc_times)
+        self._times = np.array(dc_times)
 
-        if test_monotonicity(self.times) is False:
+        if test_monotonicity(self._times) is False:
             raise FinError("Times are not sorted in increasing order")
 
     ###########################################################################
@@ -78,9 +78,9 @@ def _zero_rate(self, times: Union[float, np.ndarray, list]):
             l_index = 0
             found = 0
 
-            num_times = len(self.times)
+            num_times = len(self._times)
             for i in range(1, num_times):
-                if self.times[i] > t:
+                if self._times[i] > t:
                     l_index = i - 1
                     found = 1
                     break

financepy/market/curves/discount_curve_pwl.py

@@ -24,7 +24,7 @@ class DiscountCurvePWL(DiscountCurve):
     """Curve is made up of a series of sections assumed to each have a
     piece-wise linear zero rate. The zero rate has a specified frequency
     which defaults to continuous. This curve inherits all of the extra methods
-    from FinDiscountCurve."""
+    from DiscountCurve."""
 
     def __init__(
         self,
@@ -53,7 +53,7 @@ def __init__(
 
         dc_times = times_from_dates(zero_dts, self.value_dt, self.dc_type)
 
-        self.times = np.array(dc_times)
+        self._times = np.array(dc_times)
 
         if test_monotonicity(self.times) is False:
             raise FinError("Times are not sorted in increasing order")

financepy/market/curves/discount_curve_zeros.py

@@ -30,7 +30,7 @@ class DiscountCurveZeros(DiscountCurve):
     compute the year fraction correctly and for this we require a day count
     convention. Finally, we need to interpolate the zero rate for the times
     between the zero rates given and for this we must specify an interpolation
-    convention. The class inherits methods from FinDiscountCurve."""
+    convention. The class inherits methods from DiscountCurve."""
 
     ###############################################################################
 
@@ -101,7 +101,7 @@ def __init__(
     #             t = times[i]
     #             discount_factors[i] = discount_factors[i] * np.exp(-bump_size*t)
 
-    #         disc_curve = FinDiscountCurve(self.value_dt, times,
+    #         disc_curve = DiscountCurve(self.value_dt, times,
     #                                      discount_factors,
     #                                      self._interp_type)
 

financepy/products/bonds/bond_yield_curve.py

@@ -30,7 +30,7 @@ class BondYieldCurve:
     """Class to do fitting of the yield curve and to enable interpolation of
     yields. Because yields assume a flat term structure for each bond, this
     class does not allow discounting to be done and so does not inherit from
-    FinDiscountCurve. It should only be used for visualisation and simple
+    DiscountCurve. It should only be used for visualisation and simple
     interpolation but not for full term-structure-consistent pricing."""
 
     def __init__(