Merge pull request #20 from carlobortolan/3-implement-black-scholes-model

Implement black scholes model

Author: carlobortolan

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "quantrs"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Carlo Bortolan"]
 description = " A tiny Rust library for quantitative finance"
 license = "MIT"

Cargo.lock.MSRV

@@ -23,14 +23,81 @@ Please check out the documentation [here][docs-url].
 
 ## Features
 
-### Core Features
+## Features
+
+### Options Pricing
+
+For now quantrs only supports options pricing. The following features are available:
+
+- [x] Option types: European, American, Binary Cash-or-Nothing, Binary Asset-or-Nothing
+- [x] Option pricing: Black-Scholes, Binomial Tree, Monte Carlo Simulation
+- [x] Greeks: Delta, Gamma, Theta, Vega, Rho
+- [x] Implied volatility
+
+| Model                   | Black-Scholes       | Binomial Tree | Monte Carlo Simulation |
+| ----------------------- | ------------------- | ------------- | ---------------------- |
+| European Options        | ✅                  | ✅            | ⏳                     |
+| American Options        | ❌ (not applicable) | ✅            | ⏳                     |
+| Binary Cash-or-Nothing  | ✅                  | ❌            | ❌                     |
+| Binary Asset-or-Nothing | ⏳                  | ❌            | ❌                     |
+| Greeks                  | ✅                  | ⏳            | ⏳                     |
+| Implied Volatility      | ✅ (not tested yet) | ⏳            | ⏳                     |
+
+(✅ = Supported, ⏳ = Planned / In progress, ❌ = Not supported)
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+quantrs = "0.1.2"
+```
+
+Now if you want to e.g., model binary call options using the Black-Scholes model, you can:
+
+```rust
+use quantrs::options::*;
+
+fn main() {
+    // Create a new instrument with a spot price of 100 and a dividend yield of 2%
+    let mut instrument = Instrument::new(100.0);
+    instrument.continuous_dividend_yield = 0.02;
+
+
+    // Create a new Cash-or-Nothing binary call option with a strike price of 85
+    let option = BinaryOption::new(instrument, 85.0, OptionType::Call);
+
+    // Create a new Black-Scholes model with:
+    // - Time to maturity (T) = 0.78 years
+    // - Risk-free interest rate (r) = 5%
+    // - Volatility (σ) = 20%
+    let model = BlackScholesModel::new(0.78, 0.05, 0.2);
+
+    // Calculate the price of the binary call option using the Black-Scholes model
+    let price = model.price(option.clone());
+    println!("Price: {}", price);
+
+    // Calculate the Greeks (Delta, Gamma, Theta, Vega, Rho) for the option
+    let greeks = OptionGreeks::calculate(&model, option);
+    println!("Greeks: {:?}\n", greeks);
+}
+```
+
+This will output:
 
-- [ ] Options pricing
-  - [ ] Black-Scholes (work in progress)
-  - [ ] Binomial tree (work in progress)
-  - [ ] Monte Carlo simulation (work in progress)
-  - [ ] Greeks (work in progress)
-  - [ ] Implied volatility (work in progress)
+```text
+Price: 0.8006934914644723
+Greeks: OptionGreeks { delta: 0.013645840354947947, gamma: -0.0008813766475726433, theta: 0.17537248302290848, vega: -1.3749475702133236, rho: 0.4398346243436515 }
+```
+
+See the [documentation][docs-url] for more information and examples.
+
+## Minimum supported Rust version (MSRV)
+
+This crate requires a Rust version of 1.65.0 or higher. Increases in MSRV will be considered a semver non-breaking API change and require a version increase (PATCH until 1.0.0, MINOR after 1.0.0).
+
+## Outlook
 
 ### Planned Features
 
@@ -62,38 +129,6 @@ Please check out the documentation [here][docs-url].
   - [ ] Minimum variance
   - [ ] Maximum diversification
 
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-quantrs = "0.1"
-```
-
-Now you can use the library in your code:
-
-```rust
-use quantrs::options::*;
-
-fn main() {
-    let option = BlackScholesOption {
-        spot: 100.0,
-        strike: 100.0,
-        time_to_maturity: 1.0,
-        risk_free_rate: 0.05,
-        volatility: 0.2,
-    };
-    println!("Option price: {}", option.price(OptionType::Call));
-}
-```
-
-See the [documentation][docs-url] and the [examples](examples) for more information.
-
-## Minimum supported Rust version (MSRV)
-
-This crate requires a Rust version of 1.65.0 or higher. Increases in MSRV will be considered a semver non-breaking API change and require a version increase (PATCH until 1.0.0, MINOR after 1.0.0).
-
 ## Contributing
 
 If you find any bugs or have suggestions for improvement, please open a new issue or submit a pull request.

Cargo.toml

@@ -1,72 +1,56 @@
 // Run:  cargo run --release --example options_pricing
 
 use quantrs::options::{
-    BinomialTreeOption, BlackScholesOption, Greeks, MonteCarloOption, OptionGreeks, OptionPricing,
-    OptionStyle, OptionType,
+    BinaryOption, BinomialTreeModel, BlackScholesModel, EuropeanOption, Greeks, Instrument,
+    MonteCarloModel, Option, OptionGreeks, OptionPricing, OptionType,
 };
 
 fn main() {
+    example_from_readme();
     example_black_scholes();
     example_binomial_tree();
     example_greeks();
     example_monte_carlo();
 }
 
 fn example_black_scholes() {
-    let bs_option = BlackScholesOption {
-        spot: 100.0,
-        strike: 100.0,
-        time_to_maturity: 1.0,
-        risk_free_rate: 0.05,
-        volatility: 0.2,
-        ..Default::default()
-    };
-
-    let call_price = bs_option.price(OptionType::Call);
+    let instrument = Instrument::new(100.0);
+    let option = EuropeanOption::new(instrument, 100.0, OptionType::Call);
+    let model = BlackScholesModel::new(1.0, 0.05, 0.2);
+
+    let call_price = model.price(option.clone());
     println!("Black-Scholes Call Price: {}", call_price);
 
-    let put_price = bs_option.price(OptionType::Put);
+    let put_price = model.price(option.clone().flip());
     println!("Black-Scholes Put Price: {}", put_price);
 
     let market_price = 10.0; // Example market price
-    let implied_volatility = bs_option.implied_volatility(market_price, OptionType::Call);
-    println!("Implied Volatility: {}", implied_volatility);
+    let implied_volatility = model.implied_volatility(option, market_price);
+    println!("Implied Volatility: {}\n", implied_volatility);
 }
 
 fn example_binomial_tree() {
-    let bt_option = BinomialTreeOption {
-        spot: 100.0,
-        strike: 100.0,
-        time_to_maturity: 1.0,
-        risk_free_rate: 0.05,
-        volatility: 0.2,
-        steps: 100,
-        style: OptionStyle::American,
-    };
-
-    let bt_call_price = bt_option.price(OptionType::Call);
-    println!("Binomial Tree Call Price: {}", bt_call_price);
-
-    let bt_put_price = bt_option.price(OptionType::Put);
-    println!("Binomial Tree Put Price: {}", bt_put_price);
+    let instrument = Instrument::new(100.0);
+    let option = EuropeanOption::new(instrument, 100.0, OptionType::Call);
+    let model = BinomialTreeModel::new(1.0, 0.05, 0.2, 100);
+
+    let call_price = model.price(option.clone());
+    println!("Binomial Tree Call Price: {}", call_price);
+
+    let put_price = model.price(option.clone().flip());
+    println!("Binomial Tree Put Price: {}", put_price);
 
     let market_price = 10.0; // Example market price
-    let implied_volatility = bt_option.implied_volatility(market_price, OptionType::Call);
-    println!("Implied Volatility: {}", implied_volatility);
+    let implied_volatility = model.implied_volatility(option, market_price);
+    println!("Implied Volatility: {}\n", implied_volatility);
 }
 
 fn example_greeks() {
-    let bt_option = BinomialTreeOption {
-        spot: 100.0,
-        strike: 100.0,
-        time_to_maturity: 1.0,
-        risk_free_rate: 0.05,
-        volatility: 0.2,
-        steps: 100,
-        ..Default::default()
-    };
-
-    let greeks = OptionGreeks::calculate(&bt_option, OptionType::Call);
+    let instrument = Instrument::new(100.0);
+    let option = EuropeanOption::new(instrument, 100.0, OptionType::Call);
+    let model = BlackScholesModel::new(1.0, 0.05, 0.2);
+
+    let greeks = OptionGreeks::calculate(&model, option.clone());
 
     println!("Delta: {}", greeks.delta);
     println!("Gamma: {}", greeks.gamma);
@@ -75,31 +59,38 @@ fn example_greeks() {
     println!("Rho: {}", greeks.rho);
 
     // Greeks via function calls
-    println!("Delta: {}", bt_option.delta(OptionType::Call));
-    println!("Gamma: {}", bt_option.gamma(OptionType::Call));
-    println!("Theta: {}", bt_option.theta(OptionType::Call));
-    println!("Vega: {}", bt_option.vega(OptionType::Call));
-    println!("Rho: {}", bt_option.rho(OptionType::Call));
+    println!("Delta: {}", model.delta(option.clone()));
+    println!("Gamma: {}", model.gamma(option.clone()));
+    println!("Theta: {}", model.theta(option.clone()));
+    println!("Vega: {}", model.vega(option.clone()));
+    println!("Rho: {}\n", model.rho(option.clone()));
 }
 
 fn example_monte_carlo() {
-    let mc_option = MonteCarloOption {
-        spot: 100.0,
-        strike: 100.0,
-        time_to_maturity: 1.0,
-        risk_free_rate: 0.05,
-        volatility: 0.2,
-        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);
+    let instrument = Instrument::new(100.0);
+    let option = EuropeanOption::new(instrument, 100.0, OptionType::Call);
+    let model = MonteCarloModel::new(1.0, 0.05, 0.2, 10_000);
+
+    let call_price = model.price(option.clone());
+    println!("Monte Carlo Call Price: {}", call_price);
+
+    let put_price = model.price(option.clone().flip());
+    println!("Monte Carlo Put Price: {}", put_price);
+
+    let market_price = call_price; // Example market price
+    let implied_volatility = model.implied_volatility(option, market_price);
+    println!("Implied Volatility: {}\n", implied_volatility);
+}
+
+fn example_from_readme() {
+    let mut instrument = Instrument::new(100.0);
+    instrument.continuous_dividend_yield = 0.02;
+    let option = BinaryOption::new(instrument, 85.0, OptionType::Call);
+    let model = BlackScholesModel::new(0.78, 0.05, 0.2);
+
+    let price = model.price(option.clone());
+    println!("Price: {}", price);
+
+    let greeks = OptionGreeks::calculate(&model, option);
+    println!("Greeks: {:?}\n", greeks);
 }

README.md

@@ -1,6 +1,28 @@
-//! # quantrs
 //!
-//! A tiny Rust library for options pricing, portfolio optimization, and risk analysis.
+//! This crate is designed to be simple and easy to use library for options pricing, portfolio optimization, and risk analysis. It is not intended to be a full-fledged quantitative finance library.
+//! The goal is to provide library for pricing options, calculating greeks, and performing basic risk analysis without the need to write complex code or have a PhD in reading quantlib documentation.
+//! The library is still in the early stages of development, and many features are not yet implemented.
+//!
+//! There are no benchmarks yet, but it is expected to be faster than FinancePy, optlib, QuantScale and easier to use than RustQuant or QuantLib.
+//!
+//! ## Options Pricing
+//!
+//! For now quantrs only supports options pricing. The following features are available:
+//!
+//! - Option types: European, American, Binary Cash-or-Nothing, Binary Asset-or-Nothing
+//! - Option pricing: Black-Scholes, Binomial Tree, Monte Carlo Simulation
+//! - Greeks: Delta, Gamma, Theta, Vega, Rho
+//! - Implied volatility
+//!
+//! ```rust
+//! use quantrs::options::*;
+//!
+//! let mut instrument = Instrument::new(100.0);
+//! let option = BinaryOption::new(instrument, 85.0, OptionType::Call);
+//! let model = BlackScholesModel::new(0.78, 0.05, 0.2);
+//! let price = model.price(option.clone());
+//! let greeks = OptionGreeks::calculate(&model, option);
+//! ```
 
 #![allow(unused_variables)]