Add findZeroNPVStrike first-draft (naive bisection method)

Author: phaedon

derivatives/target_redemption_forward.h

@@ -78,8 +78,6 @@ class TargetRedemptionForward {
     while (t < end_date_years_ && !trigger_reached) {
       const double z = absl::Gaussian<double>(bitgen_, 0, 1);
       const double stoch_term = sigma * std::sqrt(dt) * z;
-      //   double r_d = domestic_rates.forwardRate(t, t + dt);
-      //   double r_f = foreign_rates.forwardRate(t, t + dt);
       const double drift_term = (r_d - r_f - 0.5 * sigma * sigma) * dt;
 
       t += dt;
@@ -152,6 +150,50 @@ class TargetRedemptionForward {
   mutable absl::BitGen bitgen_;
 };
 
+inline double findZeroNPVStrike(double notional,
+                                double target,
+                                double end_date_years,
+                                double settlement_date_frequency,
+                                FxTradeDirection direction,
+                                double spot,
+                                double sigma,
+                                const RatesCurve& foreign_rates,
+                                const RatesCurve& domestic_rates) {
+  // 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;
+  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;
+
+  // Initial method: bisection.
+  while (std::abs(k_high / k_low - 1) > tolerance_pct) {
+    TargetRedemptionForward tarf_mid(notional,
+                                     target,
+                                     k_mid,
+                                     end_date_years,
+                                     settlement_date_frequency,
+                                     direction);
+
+    double npv_mid =
+        tarf_mid.price(spot, sigma, dt, 4000, foreign_rates, domestic_rates);
+
+    if (npv_mid > 0) {
+      k_low = k_mid;
+    } else if (npv_mid < 0) {
+      k_high = k_mid;
+    }
+    k_mid = 0.5 * (k_low + k_high);
+  }
+  return k_mid;
+}
+
 }  // namespace smileexplorer
 
 #endif  //  SMILEEXPLORER_DERIVATIVES_TARGET_REDEMPTION_FORWARD_H_

derivatives/target_redemption_forward_test.cpp

@@ -107,5 +107,56 @@ TEST_F(TargetRedemptionForwardTest, KnockoutAlmostDeterministic) {
   }
 }
 
+TEST_F(TargetRedemptionForwardTest, VegaIsNegative) {
+  TargetRedemptionForward tarf(
+      1e6, 6e6, 131., 4.0, 0.25, FxTradeDirection::kLong);
+
+  double vol_low = 0.05;
+  double npv_vol_lower =
+      tarf.price(125., vol_low, 0.1, 10000, *foreign_curve_, *domestic_curve_);
+  double npv_vol_higher = tarf.price(
+      125., vol_low + 0.01, 0.1, 10000, *foreign_curve_, *domestic_curve_);
+
+  EXPECT_GT(npv_vol_lower, npv_vol_higher);
+}
+
+TEST_F(TargetRedemptionForwardTest, FindZeroNPVStrike) {
+  const double strike = findZeroNPVStrike(1e6,
+                                          100e6,
+                                          4,
+                                          0.25,
+                                          FxTradeDirection::kLong,
+                                          125,
+                                          0.0001,
+                                          *foreign_curve_,
+                                          *domestic_curve_);
+
+  EXPECT_NEAR(135.657, strike, 0.002);
+}
+
+TEST_F(TargetRedemptionForwardTest, LoweringTargetReducesLongStrike) {
+  const double strike_6mm = findZeroNPVStrike(1e6,
+                                              6e6,
+                                              4,
+                                              0.25,
+                                              FxTradeDirection::kLong,
+                                              125,
+                                              0.05,
+                                              *foreign_curve_,
+                                              *domestic_curve_);
+
+  const double strike_5mm = findZeroNPVStrike(1e6,
+                                              5e6,
+                                              4,
+                                              0.25,
+                                              FxTradeDirection::kLong,
+                                              125,
+                                              0.05,
+                                              *foreign_curve_,
+                                              *domestic_curve_);
+
+  EXPECT_LT(strike_5mm, strike_6mm);
+}
+
 }  // namespace
 }  // namespace smileexplorer