Add support for proper rates curves

Author: phaedon

derivatives/BUILD.bazel

@@ -74,6 +74,7 @@ cc_library(
     name = "target_redemption_forward",
     hdrs = ["target_redemption_forward.h"],
     deps = [
+        "//rates:zero_curve",
         "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/random",
     ],

derivatives/target_redemption_forward.h

@@ -5,6 +5,7 @@
 
 #include "absl/log/log.h"
 #include "absl/random/random.h"
+#include "rates/rates_curve.h"
 
 // Pricing model for Target Redemption Forward (TARF)
 
@@ -36,6 +37,8 @@ class TargetRedemptionForward {
   double path(double spot,
               double sigma,
               double dt,
+              const RatesCurve& foreign_rates,
+              const RatesCurve& domestic_rates,
               absl::BitGen& bitgen) const {
     // Each path should return not just the NPV, but also
     // - the distribution of payments (right?)
@@ -44,10 +47,6 @@ class TargetRedemptionForward {
     double cumulative_profit = 0.;
     double npv = 0.;
 
-    // Temporary placeholder: hardcode the rates.
-    double r_f = 0.04;
-    double r_d = 0.08;
-
     if (dt > settlement_date_frequency_) {
       // This ensures that dt is (at most) the maximum sensible value. It
       // shouldn't be larger than the periodic settlements. For example if the
@@ -67,9 +66,11 @@ class TargetRedemptionForward {
     double timesteps_taken = 0;
     bool trigger_reached = false;
     while (t < end_date_years_ && !trigger_reached) {
-      double z = absl::Gaussian<double>(bitgen, 0, 1);
-      double stoch_term = sigma * std::sqrt(dt) * z;
-      double drift_term = (r_d - r_f - 0.5 * sigma * sigma) * dt;
+      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;
       ++timesteps_taken;
@@ -91,27 +92,30 @@ class TargetRedemptionForward {
         }
 
         // Discount the payment amount on the domestic curve.
-        double discounted_pmt = payment_amount * std::exp(-r_d * t);
+        const double discounted_pmt = payment_amount * domestic_rates.df(t);
         npv += discounted_pmt;
 
-        // LOG(INFO) << " t:" << t << "  fx:" << fx
-        //           << "   pmt amt:" << payment_amount
-        //           << "   discounted:" << discounted_pmt;
-
         // Reset to the next period.
         timesteps_taken = 0;
       }
     }
     return npv;
   }
 
-  double price(double spot, double sigma, double dt, size_t num_paths) const {
+  double price(double spot,
+               double sigma,
+               double dt,
+               size_t num_paths,
+               // Convention: fx rate is quoted as FOR-DOM:
+               const RatesCurve& foreign_rates,
+               const RatesCurve& domestic_rates) const {
     absl::BitGen bitgen;
     if (num_paths == 0) return 0.;
 
     double mean_npv = 0.;
     for (size_t i = 1; i <= num_paths; ++i) {
-      double path_npv = path(spot, sigma, dt, bitgen);
+      double path_npv =
+          path(spot, sigma, dt, foreign_rates, domestic_rates, bitgen);
       // Compute the online mean at each step for numerical stability.
       mean_npv += (path_npv - mean_npv) / static_cast<double>(i);
     }

derivatives/target_redemption_forward_test.cpp

@@ -2,6 +2,8 @@
 
 #include <gtest/gtest.h>
 
+#include "rates/zero_curve.h"
+
 namespace smileexplorer {
 namespace {
 
@@ -23,13 +25,19 @@ TEST(TargetRedemptionForwardTest, AtmForward) {
   strip of forwards. For reference, the accumulated profit of the profitable
   forwards would be 48mm ISK.
   */
+  ZeroSpotCurve domestic_curve(
+      {1, 3}, {0.08, 0.08}, CompoundingPeriod::kContinuous);
+  ZeroSpotCurve foreign_curve(
+      {1, 3}, {0.04, 0.04}, CompoundingPeriod::kContinuous);
+
   const double expected_npv = 0.;
   const double error_threshold = 20000;
 
   TargetRedemptionForward tarf(1e6, 100e6, 135.657, 4.0, 0.25);
 
   for (int i = 0; i < 5; ++i) {
-    double npv = tarf.price(125., 0.0004, 0.1, 10000);
+    double npv =
+        tarf.price(125., 0.0004, 0.1, 10000, foreign_curve, domestic_curve);
     EXPECT_LT(std::abs(npv - expected_npv), error_threshold);
   }
 }
@@ -44,12 +52,51 @@ TEST(TargetRedemptionForwardTest, OtmForward) {
   in an NPV of almost exactly 50mm ISK.
   */
 
+  ZeroSpotCurve domestic_curve(
+      {1, 3}, {0.08, 0.08}, CompoundingPeriod::kContinuous);
+  ZeroSpotCurve foreign_curve(
+      {1, 3}, {0.04, 0.04}, CompoundingPeriod::kContinuous);
+
   const double expected_npv = 50e6;
   const double error_threshold = 20000;
 
   TargetRedemptionForward tarf(1e6, 100e6, 131.9686, 4.0, 0.25);
   for (int i = 0; i < 5; ++i) {
-    double npv = tarf.price(125., 0.0004, 0.1, 10000);
+    double npv =
+        tarf.price(125., 0.0004, 0.1, 10000, foreign_curve, domestic_curve);
+
+    EXPECT_LT(std::abs(npv - expected_npv), error_threshold);
+  }
+}
+
+TEST(TargetRedemptionForwardTest, KnockoutAlmostDeterministic) {
+  /*
+  Similar to the AtmForward case above, but with a 6mm ISK cumulative profit
+  target. At a very low vol, this is almost certain to happen at year 2.75 (with
+  positive payments at t=[2.25, 2.5, 2.75]).
+
+  The expected NPV is very negative here, because we are using the ATM fwd as
+  the strike, yet we have a fairly low profit target and a large interest-rate
+  differential. Therefore, there are large accumulated losses in the first 2
+  years (around -39mm ISK, not discounted) and only +6mm ISK worth of profits
+  due to the fixed target.
+  */
+
+  ZeroSpotCurve domestic_curve(
+      {1, 3}, {0.08, 0.08}, CompoundingPeriod::kContinuous);
+  ZeroSpotCurve foreign_curve(
+      {1, 3}, {0.04, 0.04}, CompoundingPeriod::kContinuous);
+
+  // This is the discounted amount of the approx. -33mm in total losses (-39mm +
+  // 6mm):
+  const double expected_npv = -31.75e6;
+  const double error_threshold = 20000;
+
+  TargetRedemptionForward tarf(1e6, 6e6, 135.657, 4.0, 0.25);
+
+  for (int i = 0; i < 5; ++i) {
+    double npv =
+        tarf.price(125., 0.0004, 0.1, 10000, foreign_curve, domestic_curve);
     EXPECT_LT(std::abs(npv - expected_npv), error_threshold);
   }
 }