Added reset flows method for bonds

Author: domokane

financepy/products/bonds/bond.py

@@ -21,6 +21,7 @@
 # GET THE COUPON AND THE ACCRUED INTEREST EQUALS THE COUPON.
 ########################################################################################
 
+from typing import List
 from enum import Enum
 import numpy as np
 from scipy import optimize
@@ -157,7 +158,8 @@ def __init__(
         self.bd_type = bd_type
         self.dg_type = dg_type
 
-        self._calculate_unadjusted_cpn_dts()
+        self._calculate_cpn_dts()
+        self._calculate_payment_dts()
         self._calculate_flow_amounts()
 
         self._pcd = None
@@ -170,7 +172,7 @@ def __init__(
 
     ####################################################################################
 
-    def _calculate_unadjusted_cpn_dts(self):
+    def _calculate_cpn_dts(self):
         """Determine the unadjusted bond coupon dts. Note that for analytical
         calculations these are not usually adjusted and so may fall on a
         weekend or holiday.
@@ -203,23 +205,20 @@ def _calculate_payment_dts(self):
         bus_day_adj_type = BusDayAdjustTypes.FOLLOWING
         calendar = Calendar(self.cal_type)
 
-        self._calculate_unadjusted_cpn_dts()
-
-        self.payment_dts = []
-
         # Expect at least an issue date and a maturity date - if not - problem
         if len(self.cpn_dts) < 2:
             raise FinError("Cannot calculate payment dts with one payment")
 
+        self.payment_dts = []
+
         # I do not adjust the first date as it is the issue date
         self.payment_dts.append(self.cpn_dts[0])
 
         for cpn_dt in self.cpn_dts[1:]:
             pmt_dt = calendar.adjust(cpn_dt, bus_day_adj_type)
-
             self.payment_dts.append(pmt_dt)
 
-    ###########################################################################
+    ####################################################################################
 
     def _calculate_flow_amounts(self):
         """Determine the bond cash flow payment amounts without principal.
@@ -231,7 +230,37 @@ def _calculate_flow_amounts(self):
             cpn = self.cpn / self.freq
             self.flow_amounts.append(cpn)
 
-    ###########################################################################
+    ####################################################################################
+
+    def reset_flows(
+        self, cpn_dts: List[Date], payment_dts: List[Date], flow_amounts: np.ndarray
+    ):
+        """Set the flows of the bond externally. Coupon dates are for accrued
+        while payment dates are calendar adjusted. Flows are on payment dates"""
+
+        n_cpn_dts = len(cpn_dts)
+        n_payment_dts = len(payment_dts)
+        n_flows = len(flow_amounts)
+
+        if n_cpn_dts != n_payment_dts:
+            raise FinError("Number of coupon dates not equal to number payments")
+
+        if n_cpn_dts != n_flows:
+            raise FinError("Number of coupon dates not equal to number flows")
+
+        for i in range(1, n_cpn_dts):
+
+            if cpn_dts[i] < cpn_dts[i - 1]:
+                raise FinError("Coupon dates not in order")
+
+            if payment_dts[i] < payment_dts[i - 1]:
+                raise FinError("Payment dates not in order")
+
+        self.cpn_dts = cpn_dts
+        self.payment_dts = payment_dts
+        self.flow_amounts = flow_amounts
+
+    ####################################################################################
 
     def dirty_price_from_ytm(
         self,
@@ -275,7 +304,7 @@ def dirty_price_from_ytm(
 
         # n is the number of flows after the next coupon
         n = 0
-        for dt in self.cpn_dts:
+        for dt in self.payment_dts:
             if dt > settle_dt:
                 n += 1
         n = n - 1
@@ -292,7 +321,6 @@ def dirty_price_from_ytm(
                 term3 = (c / f) * v * v * (1.0 - v ** (n - 1)) / (1.0 - v)
                 term4 = v**n
                 dp = (v ** (self.alpha)) * (term1 + term2 + term3 + term4)
-        #                print(term1, term2, term3, term4, v, self.alpha, dp)
         elif convention == YTMCalcType.US_TREASURY:
             if n == 0:
                 dp = (v ** (self.alpha)) * (1.0 + c / f)
@@ -365,7 +393,7 @@ def forward_price(
         accrued_forward = self.accrued_interest(forward_dt)
 
         fv_cpns = 0.0
-        for dt, amt in zip(self.cpn_dts[1:], self.flow_amounts[1:]):
+        for dt, amt in zip(self.payment_dts[1:], self.flow_amounts[1:]):
             if settle_dt < dt <= forward_dt:
                 t_cpn_to_forward, _, _ = dc.year_frac(dt, forward_dt)
                 fv_cpns += amt * self.par * (1 + repo_rate * t_cpn_to_forward)
@@ -664,14 +692,14 @@ def dirty_price_from_discount_curve(
         df = 1.0
         df_settle_dt = discount_curve.df(settle_dt)
 
-        dt = self.cpn_dts[1]
+        dt = self.payment_dts[1]
         if dt > settle_dt:
             df = discount_curve.df(dt)
             flow = self.cpn / self.freq
             pv = flow * df
             px += pv * pay_first_cpn
 
-        for dt in self.cpn_dts[2:]:
+        for dt in self.payment_dts[2:]:
 
             # coupons paid on a settlement date are paid to the seller
             if dt > settle_dt:
@@ -820,7 +848,7 @@ def asset_swap_spread(
         pv_ibor = 0.0
         prev_dt = self._pcd
 
-        for dt in self.cpn_dts[1:]:
+        for dt in self.payment_dts[1:]:
 
             # coupons paid on a settlement date are paid to the seller
             if dt > settle_dt:
@@ -901,7 +929,7 @@ def dirty_price_from_oas(
         df_adjusted = 1.0
 
         pv = 0.0
-        for dt in self.cpn_dts[1:]:
+        for dt in self.payment_dts[1:]:
 
             # coupons paid on a settlement date are paid to the seller
             if dt > settle_dt:
@@ -999,7 +1027,7 @@ def dirty_price_from_survival_curve(
         defaulting_pv_pay_start = 0.0
         defaulting_pv_pay_end = 0.0
 
-        for dt in self.cpn_dts[1:]:
+        for dt in self.payment_dts[1:]:
 
             # coupons paid on a settlement date are paid to the seller
             if dt > settle_dt:
@@ -1068,7 +1096,7 @@ def calc_ror(
         """
         buy_price = self.dirty_price_from_ytm(begin_dt, begin_ytm, convention)
         sell_price = self.dirty_price_from_ytm(end_dt, end_ytm, convention)
-        dts_cfs = zip(self.cpn_dts, self.flow_amounts)
+        dts_cfs = zip(self.payment_dts, self.flow_amounts)
 
         # The coupon or par payments on buying date belong to the buyer. The
         # coupon or par payments on selling date are given to the new buyer.
@@ -1121,13 +1149,20 @@ def print_payments(self, settle_dt: Date, face: float = 100):
         flow = face * self.cpn / self.freq
         flow_str = ""
 
-        for dt in self.cpn_dts[1:-1]:
+        n_flows = len(self.cpn_dts)
+
+        for i in range(0, n_flows):
+
             # coupons paid on a settlement date are paid to the seller
-            if dt > settle_dt:
-                flow_str += "%12s %12.5f \n" % (dt, flow)
+            cpn_dt = self.cpn_dts[i]
+            pmt_dt = self.payment_dts[i]
+            flow = self.flow_amounts[i]
+
+            if cpn_dt > settle_dt:
+                flow_str += "%12s %12s %12.5f \n" % (cpn_dt, pmt_dt, flow)
 
         redemption_amount = face + flow
-        flow_str += "%12s %12.5f \n" % (self.cpn_dts[-1], redemption_amount)
+        flow_str += "%12s %12s %12.5f \n" % (cpn_dt, pmt_dt, redemption_amount)
 
         print(flow_str)
 

financepy/products/fx/fx_double_one_touch_option.py

@@ -24,7 +24,7 @@
 
 
 @njit(fastmath=True, parallel=True, cache=True)
-def _p_touch_bb_parallel(
+def _p_double_touch_bb_parallel(
     S0: float,
     L: float,
     U: float,
@@ -468,7 +468,9 @@ def value_mc(
         steps = int(max(1, num_steps_per_year * T))
 
         # Estimate touch probability with Brownian bridge (parallel)
-        p_touch = _p_touch_bb_parallel(S0, L, U, mu, sigma, T, steps, num_paths, seed)
+        p_touch = _p_double_touch_bb_parallel(
+            S0, L, U, mu, sigma, T, steps, num_paths, seed
+        )
 
         if self.option_type == DoubleBarrierTypes.KNOCK_OUT:
             # Double no-touch

golden_tests/TestFinBond.py

@@ -513,21 +513,46 @@ def test_bond_ex_dividend():
 
 def test_bond_payment_dates():
 
+    issue_dt = Date(1, 1, 2020)
+    mat_dt = Date(1, 1, 2023)
+    cpn = 0.05
+    ytm = 0.05
+    face = 100.0
+
+    # Use auto generated schedule
     bond = Bond(
-        issue_dt=Date(7, 6, 2021),
-        maturity_dt=Date(7, 6, 2031),
-        coupon=0.0341,
+        issue_dt=issue_dt,
+        maturity_dt=mat_dt,
+        coupon=cpn,
         freq_type=FrequencyTypes.ANNUAL,
         dc_type=DayCountTypes.ACT_ACT_ISDA,
+        cal_type=CalendarTypes.UNITED_STATES,
     )
-    bond._calculate_payment_dts()
 
-    DEBUG = False
+    settle_dt = issue_dt.add_months(3)
+    #    bond.print_payments(settle_dt)
 
-    if DEBUG:
-        print(bond.flow_amounts)
-        print(bond.cpn_dts)
-        print(bond._payment_dts)
+    accrued = bond.accrued_interest(settle_dt, face)
+    dirty_price = bond.dirty_price_from_ytm(settle_dt, ytm)
+    clean_price = dirty_price - accrued
+    test_cases.print(settle_dt, dirty_price, accrued, clean_price)
+    #    print(settle_dt, dirty_price, accrued, clean_price)
+
+    # Use manual schedule where I make payment dates equal coupon dates even weekends
+    cpn_dts = [Date(1, 1, 2020), Date(1, 1, 2021), Date(1, 1, 2022), Date(1, 1, 2023)]
+    pmt_dts = [Date(1, 1, 2020), Date(1, 1, 2021), Date(1, 1, 2022), Date(1, 1, 2023)]
+    flow_amts = np.array([0.0, 0.05, 0.05, 1.05])
+
+    bond.reset_flows(cpn_dts, pmt_dts, flow_amts)
+    #    bond.print_payments(settle_dt)
+
+    accrued = bond.accrued_interest(settle_dt, face)
+    dirty_price = bond.dirty_price_from_ytm(settle_dt, ytm)
+    clean_price = dirty_price - accrued
+    test_cases.print(settle_dt, dirty_price, accrued, clean_price)
+
+
+#    print(settle_dt, dirty_price, accrued, clean_price)
 
 
 ########################################################################################
@@ -602,6 +627,8 @@ def test_bond_eom():
 
     accrued_interest = bond.accrued_interest(settle_dt)  # should be 8406.593406
 
+    # print(accrued_interest)
+
 
 ########################################################################################