Add weightedAvgForward function for computing vanilla (no knockout) atmfwd strikes

Author: phaedon

derivatives/target_redemption_forward.h

@@ -34,6 +34,47 @@ class TargetRedemptionForward {
         settlement_date_frequency_(settlement_date_frequency),
         direction_(direction) {}
 
+  /* Returns the weighted average of the forward FX rate, weighted by the
+     discount factors.
+
+    As a simple example, suppose spot is at 100 and there are 3 periods of
+    interest, with the following forward FX rates and the following discount
+    factors from the `domestic_rates` curve:
+
+    t (yrs)   fwd     df
+    -------   ---     ---
+      1       102     0.95
+      2       104     0.90
+      3       106     0.85
+
+    Then this function would return ~103.9259
+    or in spreadsheet pseudocode:
+        = sumproduct(fwd, df)/sum(df)
+  */
+  double weightedAvgForward(double spot,
+                            const RatesCurve& foreign_rates,
+                            const RatesCurve& domestic_rates) const {
+    double sumproduct = 0.;
+    double fx = spot;
+    double df_sum = 0.;
+
+    int num_payments = std::round(end_date_years_ / settlement_date_frequency_);
+    for (int i = 1; i <= num_payments; ++i) {
+      double t_init = (i - 1) * settlement_date_frequency_;
+      double t_final = i * settlement_date_frequency_;
+      double rd = domestic_rates.forwardRate(t_init, t_final);
+      double rf = foreign_rates.forwardRate(t_init, t_final);
+      fx *= std::exp((rd - rf) * settlement_date_frequency_);
+      sumproduct += fx * domestic_rates.df(t_final);
+      df_sum += domestic_rates.df(t_final);
+    }
+
+    // Sanity check in case of degenerate case.
+    if (df_sum <= 0.) return 0.;
+
+    return sumproduct / df_sum;
+  }
+
   // Initial implementation: given a flat volatility and a specified forward,
   // price the scenarios using the provided discount curve. (It is up to the
   // client to ensure that the current discount curve is provided, otherwise a
@@ -162,15 +203,23 @@ inline double findZeroNPVStrike(double notional,
   // TODO: compute the forward for a more intelligent starting guess.
   // AND ALSO then verify that the value of one is positive and the other is
   // negative.
-  double k_low = spot * 0.5;
-  double k_high = spot * 2;
+  TargetRedemptionForward tarf_forward(notional,
+                                       target,
+                                       spot,
+                                       end_date_years,
+                                       settlement_date_frequency,
+                                       direction);
+  double atm_fwd =
+      tarf_forward.weightedAvgForward(spot, foreign_rates, domestic_rates);
+  double k_low = atm_fwd * 0.5;
+  double k_high = atm_fwd * 1.1;
   double k_mid = 0.5 * (k_low + k_high);
 
   double tolerance_pct =
       0.0001;  // 0.01% difference for starters. Do not hard-code!
 
-  // TODO is there ever a need to have this be smaller than the period?
-  double dt = settlement_date_frequency * 0.5;
+  // Relatively coarse timesteps.
+  double dt = settlement_date_frequency * 0.2;
 
   // Initial method: bisection.
   while (std::abs(k_high / k_low - 1) > tolerance_pct) {
@@ -182,7 +231,7 @@ inline double findZeroNPVStrike(double notional,
                                      direction);
 
     double npv_mid =
-        tarf_mid.price(spot, sigma, dt, 4000, foreign_rates, domestic_rates);
+        tarf_mid.price(spot, sigma, dt, 5000, foreign_rates, domestic_rates);
 
     if (npv_mid > 0) {
       k_low = k_mid;

derivatives/target_redemption_forward_test.cpp

@@ -24,7 +24,7 @@ class TargetRedemptionForwardTest : public ::testing::Test {
   std::unique_ptr<ZeroSpotCurve> domestic_curve_;
 };
 
-TEST_F(TargetRedemptionForwardTest, AtmForward) {
+TEST_F(TargetRedemptionForwardTest, DeterministicForwardWithoutTarget) {
   /*
   Verified in a spreadsheet:
    - expiry: 4 years
@@ -33,10 +33,25 @@ TEST_F(TargetRedemptionForwardTest, AtmForward) {
    - spot fx rate: 125.0
    - USD (foreign) rate: 4%
    - ISK (domestic) rate: 8%
-   - notional: $1,000,000
 
-   At this interest rate differential, the discount-weighted average of the
+  Rates are flat and continuously compounded.
+
+  At this interest rate differential, the discount-weighted average of the
   forwards is 135.657.
+  */
+
+  TargetRedemptionForward tarf(
+      100, 100, 125, 4.0, 0.25, FxTradeDirection::kLong);
+
+  EXPECT_NEAR(135.6570005,
+              tarf.weightedAvgForward(125, *foreign_curve_, *domestic_curve_),
+              1e-6);
+}
+
+TEST_F(TargetRedemptionForwardTest, AtmForwardHasZeroNPV) {
+  /*
+  This test uses the parameters described in DeterministicForwardWithoutTarget
+  above.
 
   With a high-enough target (here, 100mm ISK) and a very low vol, this is just a
   strip of forwards. For reference, the accumulated profit of the profitable
@@ -46,8 +61,14 @@ TEST_F(TargetRedemptionForwardTest, AtmForward) {
   const double expected_npv = 0.;
   const double error_threshold = 20000;
 
+  // This step is just to discover the appropriate strike.
+  TargetRedemptionForward placeholder_tarf(
+      100, 100, 125, 4.0, 0.25, FxTradeDirection::kLong);
+  double atm_fwd_strike = placeholder_tarf.weightedAvgForward(
+      125, *foreign_curve_, *domestic_curve_);
+
   TargetRedemptionForward tarf(
-      1e6, 100e6, 135.657, 4.0, 0.25, FxTradeDirection::kLong);
+      1e6, 100e6, atm_fwd_strike, 4.0, 0.25, FxTradeDirection::kLong);
 
   for (int i = 0; i < 5; ++i) {
     double npv =
@@ -63,7 +84,8 @@ TEST_F(TargetRedemptionForwardTest, OtmForward) {
   of the NPV computations is correct.
 
   At a strike of 131.9686 and the other params kept the same, this should result
-  in an NPV of almost exactly 50mm ISK.
+  in an NPV of almost exactly 50mm ISK. This was verified / computed in a
+  spreadsheet.
   */
 
   const double expected_npv = 50e6;