feat(options): implement bermudan options (#53)

* Implement bermudan option

* Implement bermudan option

* Update src/options/types/bermudan_option.rs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update BermudanOption

* Implement bermudan option

---------

Signed-off-by: Carlo Bortolan <106114526+carlobortolan@users.noreply.github.com>

Author: carlobortolan

README.md

@@ -38,7 +38,7 @@ Quantrs supports options pricing with various models for both vanilla and exotic
 | --------------------------- | --------------- | -------- | ------------ | ------------ | ------------- | ------ |
 | European                    | ✅              | ✅       | ✅           | ✅           | ⏳            | ⏳     |
 | American                    | ❌              | ❌       | ✅           | ❌ (L. Sq.)  | ⏳            | ❌     |
-| Bermudan                    | ❌              | ❌       | ⏳           | ❌ (L. Sq.)  | ❌ (complex)  | ❌     |
+| Bermudan                    | ❌              | ❌       | ✅           | ❌ (L. Sq.)  | ❌ (complex)  | ❌     |
 | ¹Basket                     | ⏳ (∀component) | ❌       | ⏳ (approx.) | ⏳           | ❌            | ❌     |
 | ¹Rainbow                    | ✅ (∀component) | ❌       | ✅           | ✅           | ❌            | ❌     |
 | ²Barrier                    | ❌ (mod. BSM)   | ❌       | ⏳           | ⏳           | ⏳            | ⏳     |

src/options/models/binomial_tree.rs

@@ -138,7 +138,13 @@ impl OptionPricing for BinomialTreeModel {
                 let expected_value =
                     discount_factor * (p * option_values[i + 1] + (1.0 - p) * option_values[i]);
 
-                if matches!(option.style(), OptionStyle::American) {
+                if matches!(option.style(), OptionStyle::American)
+                    || matches!(option.style(), OptionStyle::Bermudan)
+                        && option
+                            .expiration_dates()
+                            .unwrap()
+                            .contains(&(step as f64 * dt))
+                {
                     let early_exercise = option.payoff(Some(
                         option.instrument().spot() * u.powi(i as i32) * d.powi((step - i) as i32),
                     ));
@@ -149,7 +155,10 @@ impl OptionPricing for BinomialTreeModel {
             }
         }
 
-        if matches!(option.style(), OptionStyle::American) {
+        if matches!(option.style(), OptionStyle::American)
+            || matches!(option.style(), OptionStyle::Bermudan)
+                && option.expiration_dates().unwrap().contains(&0.0)
+        {
             option_values[0].max(option.strike() - option.instrument().spot()) // TODO: Change to max(0.0, self.payoff(Some(self.spot)))
         } else {
             option_values[0] // Return the root node value

src/options/traits/option.rs

@@ -41,6 +41,15 @@ pub trait Option: Clone + Send + Sync {
     /// The time horizon (in years).
     fn time_to_maturity(&self) -> f64;
 
+    /// Get the expiration dates of the option.
+    ///     
+    /// # Returns
+    ///
+    /// The expiration dates of the option. (Only for Bermudan options)
+    fn expiration_dates(&self) -> std::option::Option<&Vec<f64>> {
+        None
+    }
+
     /// Set the time horizon (in years).
     ///
     /// # Arguments

src/options/types.rs

@@ -6,13 +6,15 @@
 
 pub use american_option::AmericanOption;
 pub use asian_option::AsianOption;
+pub use bermudan_option::BermudanOption;
 pub use binary_option::BinaryOption;
 pub use european_option::EuropeanOption;
 pub use lookback_option::LookbackOption;
 pub use rainbow_option::RainbowOption;
 
 mod american_option;
 mod asian_option;
+mod bermudan_option;
 mod binary_option;
 mod european_option;
 mod lookback_option;

src/options/types/bermudan_option.rs

@@ -0,0 +1,106 @@
+//! Module for Bermudan option type.
+//!
+//! A Bermuda option can be exercised early, but only on a set of specific dates before its expiration.
+//! These exercise dates are often set in one-month increments.
+//! Premiums for Bermuda options are typically lower than those of American options, which can be exercised any time before expiry.
+
+use std::any::Any;
+
+use super::{OptionStyle, OptionType};
+use crate::{
+    log_warn,
+    options::{Instrument, Option},
+};
+
+/// A struct representing an Bermudan option.
+#[derive(Clone, Debug)]
+pub struct BermudanOption {
+    /// The underlying instrument.
+    pub instrument: Instrument,
+    /// Strike price of the option (aka exercise price).
+    pub strike: f64,
+    /// The time horizon (in years).
+    pub time_to_maturity: f64,
+    /// The expiration dates of the option (in years).
+    pub expiration_dates: Vec<f64>,
+    /// Type of the option (Call or Put).
+    pub option_type: OptionType,
+}
+
+impl BermudanOption {
+    /// Create a new `BermudanOption`.
+    pub fn new(
+        instrument: Instrument,
+        strike: f64,
+        expiration_dates: Vec<f64>,
+        option_type: OptionType,
+    ) -> Self {
+        Self {
+            instrument,
+            strike,
+            time_to_maturity: if let Some(&last_date) = expiration_dates.last() {
+                last_date
+            } else {
+                log_warn!("Expiration dates are empty, setting time to maturity to 0.0");
+                0.0
+            },
+            expiration_dates,
+            option_type,
+        }
+    }
+}
+
+impl Option for BermudanOption {
+    fn instrument(&self) -> &Instrument {
+        &self.instrument
+    }
+
+    fn instrument_mut(&mut self) -> &mut Instrument {
+        &mut self.instrument
+    }
+
+    fn set_instrument(&mut self, instrument: Instrument) {
+        self.instrument = instrument;
+    }
+
+    fn strike(&self) -> f64 {
+        self.strike
+    }
+
+    fn time_to_maturity(&self) -> f64 {
+        self.time_to_maturity
+    }
+
+    fn expiration_dates(&self) -> std::option::Option<&Vec<f64>> {
+        Some(&self.expiration_dates)
+    }
+
+    fn set_time_to_maturity(&mut self, time_to_maturity: f64) {
+        self.time_to_maturity = time_to_maturity;
+    }
+
+    fn option_type(&self) -> OptionType {
+        self.option_type
+    }
+
+    fn style(&self) -> &OptionStyle {
+        &OptionStyle::Bermudan
+    }
+
+    fn flip(&self) -> Self {
+        let flipped_option_type = match self.option_type {
+            OptionType::Call => OptionType::Put,
+            OptionType::Put => OptionType::Call,
+        };
+        BermudanOption::new(
+            self.instrument.clone(),
+            self.strike,
+            self.expiration_dates.clone(),
+            flipped_option_type,
+        )
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}

tests/options_pricing.rs

@@ -1,8 +1,8 @@
 use approx::assert_abs_diff_eq;
 use quantrs::options::{
-    AmericanOption, AsianOption, BinaryOption, BinomialTreeModel, Black76Model, BlackScholesModel,
-    EuropeanOption, Greeks, Instrument, LookbackOption, MonteCarloModel, Option, OptionGreeks,
-    OptionPricing, OptionType, RainbowOption,
+    AmericanOption, AsianOption, BermudanOption, BinaryOption, BinomialTreeModel, Black76Model,
+    BlackScholesModel, EuropeanOption, Greeks, Instrument, LookbackOption, MonteCarloModel, Option,
+    OptionGreeks, OptionPricing, OptionType, RainbowOption,
 };
 
 struct MockModel {}
@@ -26,6 +26,7 @@ fn assert_implements_option_trait<T: Option>(option: &T) {
     option.clone().set_time_to_maturity(1.0);
     option.strike();
     option.time_to_maturity();
+    option.expiration_dates();
     option.option_type();
     option.style();
     option.flip();
@@ -786,6 +787,32 @@ mod binomial_tree_tests {
         }
     }
 
+    mod bermudan_option_tests {
+        use super::*;
+
+        #[test]
+        fn test_itm() {
+            let instrument = Instrument::new().with_spot(52.0);
+            let expiration_dates = vec![0.0, 1.0, 2.0];
+            let option = BermudanOption::new(instrument, 50.0, expiration_dates, OptionType::Call);
+            let model = BinomialTreeModel::new(0.05, 0.182321557, 2);
+
+            assert_abs_diff_eq!(model.price(&option), 8.8258, epsilon = 0.0001);
+            assert_abs_diff_eq!(model.price(&option.flip()), 2.5722, epsilon = 0.0001);
+        }
+
+        #[test]
+        fn test_otm() {
+            let instrument = Instrument::new().with_spot(50.0);
+            let expiration_dates = vec![0.0, 1.0, 2.0];
+            let option = BermudanOption::new(instrument, 60.0, expiration_dates, OptionType::Call);
+            let model = BinomialTreeModel::new(0.05, 0.182321557, 2);
+
+            assert_abs_diff_eq!(model.price(&option), 10.0000, epsilon = 0.0001);
+            assert_abs_diff_eq!(model.price(&option.flip()), 10.0000, epsilon = 0.0001);
+        }
+    }
+
     mod rainbow_option_tests {
         use super::*;
 
@@ -1908,6 +1935,20 @@ mod option_trait_tests {
             OptionType::Put,
         );
         assert_implements_option_trait(&opt);
+        let opt = BermudanOption::new(
+            Instrument::new().with_spot(100.0),
+            100.0,
+            vec![1.0],
+            OptionType::Call,
+        );
+        assert_implements_option_trait(&opt);
+        let opt = BermudanOption::new(
+            Instrument::new().with_spot(100.0),
+            100.0,
+            vec![1.0],
+            OptionType::Put,
+        );
+        assert_implements_option_trait(&opt);
         let opt = AsianOption::fixed(
             Instrument::new().with_spot(100.0),
             100.0,