4 implement binomial tree model (#19)

* Update README.md

* Add basic options pricing structure

* Update README.md

* Add documentation

* Add documentation

* Complete basic options pricing structure

* Update crates

* Add implied volatility calculation and extend Greeks trait for options

* Add OptionStyle enum

* Refactor option pricing implementations by removing redundant comments and cleaning up Greeks trait

* Add monte carlo greeks test

* Remove print

* Generate documentation for option pricing models and Greeks

* Add payoff calculation and strike method to option pricing traits; implement Greeks calculations in Monte Carlo option

* Implement binomial tree options pricing

* Update tests

* Update tests

* Update tests

* Update tests

* Update tests

* Update tests

* Update codecov.yml

* Update codecov.yml

Author: carlobortolan

Cargo.toml

@@ -6,8 +6,9 @@ description = " A tiny Rust library for quantitative finance"
 license = "MIT"
 # keywords = ["quantitative", "statistics", "finance", "options", "timeseries"]
 # categories = ["science"]
-homepage = "https://github.com/carlobortolan/quantrs"
 repository = "https://github.com/carlobortolan/quantrs"
+documentation = "https://docs.rs/quantrs"
+homepage = "https://github.com/carlobortolan/quantrs"
 edition = "2021"
 
 include = ["CHANGELOG.md", "LICENSE.md", "src/", "tests/"]

codecov.yml

@@ -2,6 +2,13 @@ coverage:
   status:
     project:
       default:
+        target: 90%
+        threshold: 0.5%
+        base: auto
         enabled: yes
+    patch:
+      default:
         target: 90%
-        threshold: 0.5%
+        threshold: 10%
+        base: auto
+        enabled: yes

examples/options_pricing.rs

@@ -2,7 +2,7 @@
 
 use quantrs::options::{
     BinomialTreeOption, BlackScholesOption, Greeks, MonteCarloOption, OptionGreeks, OptionPricing,
-    OptionType,
+    OptionStyle, OptionType,
 };
 
 fn main() {
@@ -19,6 +19,7 @@ fn example_black_scholes() {
         time_to_maturity: 1.0,
         risk_free_rate: 0.05,
         volatility: 0.2,
+        ..Default::default()
     };
 
     let call_price = bs_option.price(OptionType::Call);
@@ -40,6 +41,7 @@ fn example_binomial_tree() {
         risk_free_rate: 0.05,
         volatility: 0.2,
         steps: 100,
+        style: OptionStyle::American,
     };
 
     let bt_call_price = bt_option.price(OptionType::Call);
@@ -61,6 +63,7 @@ fn example_greeks() {
         risk_free_rate: 0.05,
         volatility: 0.2,
         steps: 100,
+        ..Default::default()
     };
 
     let greeks = OptionGreeks::calculate(&bt_option, OptionType::Call);
@@ -86,12 +89,17 @@ fn example_monte_carlo() {
         time_to_maturity: 1.0,
         risk_free_rate: 0.05,
         volatility: 0.2,
-        simulations: 10000,
+        simulations: 10_000,
+        ..Default::default()
     };
 
     let mc_call_price = mc_option.price(OptionType::Call);
     println!("Monte Carlo Call Price: {}", mc_call_price);
 
     let mc_put_price = mc_option.price(OptionType::Put);
     println!("Monte Carlo Put Price: {}", mc_put_price);
+
+    let market_price = mc_call_price; // Example market price
+    let implied_volatility = mc_option.implied_volatility(market_price, OptionType::Call);
+    println!("Implied Volatility: {}", implied_volatility);
 }

src/options.rs

@@ -1,4 +1,15 @@
-//! Options pricing models.
+//! Module for various option pricing models.
+//!
+//! ## Supported models
+//!
+//! - [Black-Scholes Option Pricing Model](black_scholes/struct.BlackScholesOption.html)
+//! - [Binomial Option Pricing Model](binomial_tree/struct.BinomialTreeOption.html)
+//! - [Monte Carlo Option Pricing Model](monte_carlo/struct.MonteCarloOption.html)
+//!
+//! ## Greek calculations
+//!
+//! This module also provides implementations of the Greeks for each option pricing model.
+//! See the [Greeks](options/trait.Greeks.html) trait for more information.
 
 pub mod binomial_tree;
 pub mod black_scholes;
@@ -7,17 +18,16 @@ pub mod monte_carlo;
 
 pub use binomial_tree::BinomialTreeOption;
 pub use black_scholes::BlackScholesOption;
-pub use greeks::Greeks;
 pub use greeks::OptionGreeks;
 pub use monte_carlo::MonteCarloOption;
-
-/// Enum representing the type of option.
-#[derive(Clone, Copy)]
-pub enum OptionType {
-    /// Call option
-    Call,
-    /// Put option
-    Put,
+/// Supertrait that combines OptionPricing and Greeks.
+pub trait Option: OptionPricing + Greeks {
+    /// Get the style of the option.
+    ///
+    /// # Returns
+    ///
+    /// The style of the option.
+    fn style(&self) -> &OptionStyle;
 }
 
 /// Trait for option pricing models.
@@ -44,9 +54,122 @@ pub trait OptionPricing {
     ///
     /// The implied volatility.
     fn implied_volatility(&self, market_price: f64, option_type: OptionType) -> f64;
+
+    /// Calculate the payoff of the option at maturity.
+    ///
+    /// # Arguments
+    ///
+    /// * `underlying_price` - The price of the underlying asset at maturity.
+    /// * `option_type` - The type of option (Call or Put).
+    ///
+    /// # Returns
+    ///
+    /// The payoff of the option.
+    fn payoff(&self, spot: f64, option_type: OptionType) -> f64 {
+        match option_type {
+            OptionType::Call => (spot - self.strike()).max(0.0),
+            OptionType::Put => (self.strike() - spot).max(0.0),
+        }
+    }
+
+    /// Get the strike price of the option.
+    ///
+    /// # Returns
+    ///
+    /// The strike price of the option.
+    fn strike(&self) -> f64;
+}
+
+/// Trait for calculating the Greeks of an option.
+pub trait Greeks {
+    // First order Greeks
+    /// Delta measures the rate of change of the option price with respect to changes in the price of the underlying asset.
+    fn delta(&self, option_type: OptionType) -> f64;
+    /// Gamma measures the rate of change of the option delta with respect to changes in the price of the underlying asset.
+    fn gamma(&self, option_type: OptionType) -> f64;
+    /// Theta measures the rate of change of the option price with respect to changes in time to maturity.
+    fn theta(&self, option_type: OptionType) -> f64;
+    /// Vega measures the rate of change of the option price with respect to changes in the volatility of the underlying asset.
+    fn vega(&self, option_type: OptionType) -> f64;
+    /// Rho measures the rate of change of the option price with respect to changes in the risk-free interest rate.
+    fn rho(&self, option_type: OptionType) -> f64;
+
+    // Higher order Greeks
+    /// Lambda measures the rate of change of the option delta with respect to changes in the risk-free interest rate.
+    fn lambda(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Vanna measures the rate of change of the option delta with respect to changes in the volatility of the underlying asset.
+    fn vanna(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Charm measures the rate of change of the option delta with respect to changes in time to maturity.
+    fn charm(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Vomma measures the rate of change of the option vega with respect to changes in the volatility of the underlying asset.
+    fn vomma(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Veta measures the rate of change of the option vega with respect to changes in time to maturity.
+    fn veta(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Speed measures the rate of change of the option gamma with respect to changes in the price of the underlying asset.
+    fn speed(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Zomma measures the rate of change of the option gamma with respect to changes in the volatility of the underlying asset.
+    fn zomma(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Color measures the rate of change of the option gamma with respect to changes in time to maturity.
+    fn color(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+    /// Ultima measures the rate of change of the option vomma with respect to changes in the volatility of the underlying asset.
+    fn ultima(&self, option_type: OptionType) -> f64 {
+        0.0 // Placeholder value
+    }
+}
+
+/// Enum representing the type of option.
+#[derive(Clone, Copy, Debug)]
+pub enum OptionType {
+    /// Call option (gives the holder the right to buy the underlying asset)
+    Call,
+    /// Put option (gives the holder the right to sell the underlying asset)
+    Put,
 }
 
-/// A supertrait that combines OptionPricing and Greeks.
-pub trait Option: OptionPricing + Greeks {}
+/// Enum representing the style of the option.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum OptionStyle {
+    /// American option (can be exercised at any time)
+    American,
+    /// European option (default, can be exercised only at expiration)
+    European,
+    /// Bermudan option (can be exercised at specific dates)
+    Bermudan,
+    /// Asian option (payoff depends on average price of underlying asset)
+    Asian,
+    /// Barrier option (payoff depends on whether underlying asset crosses a barrier)
+    Barrier,
+    /// Binary option (payout is fixed amount or nothing)
+    Binary,
+    /// Digital option (payout is fixed amount or nothing; also known as cash-or-nothing or asset-or-nothing option)
+    Digital,
+    /// Lookback option (payoff depends on extrema of underlying asset)
+    Lookback,
+}
 
-impl<T: OptionPricing + Greeks> Option for T {}
+impl Default for OptionStyle {
+    /// Default option style is European.
+    ///     
+    /// # Returns
+    ///
+    /// The default option style.
+    fn default() -> Self {
+        OptionStyle::European
+    }
+}