add workspace && gen docs

.github/workflows/rust.yml

@@ -6,21 +6,30 @@ on:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Cache Cargo registry
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
 
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        override: true
+      - name: Install Rust
+        uses: actions-rs/toolchain@v2
+        with:
+          toolchain: stable
+          override: true
 
-    - name: Build
-      run: cargo build --verbose
+      - name: Build
+        run: cargo build --workspace --verbose
 
-    - name: Run tests
-      run: cargo test --verbose
+      - name: Run tests
+        run: cargo test --workspace --verbose

Cargo.toml

@@ -3,16 +3,8 @@ name = "cqf"
 version = "0.1.0"
 edition = "2021"
 
-authors = ["[email protected]"]
-repository = "https://github.com/liberxue/cqf"
-homepage = "https://github.com/liberxue"
-
-
 [workspace]
-members = ["bench", "cli", "core"]
+members = ["core", "bench", "cli"]
 
 
-[profile.release]
-lto = true
-codegen-units = 1
-strip = "symbols"
+[dependencies]

bench/Cargo.toml

@@ -3,6 +3,4 @@ name = "bench"
 version = "0.1.0"
 edition = "2021"
 
-[[bin]]
-name = "bench"
-path = "src/main.rs"
+[dependencies]

cli/Cargo.toml

@@ -2,11 +2,5 @@
 name = "cli"
 version = "0.1.0"
 edition = "2021"
-authors = ["[email protected]"]
-repository = "https://github.com/liberxue/cqf"
-homepage = "https://github.com/liberxue"
-[[bin]]
-name = "cli"
-path = "src/main.rs"
 
 [dependencies]

core/Cargo.toml

@@ -4,15 +4,5 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-
-[lib]
-path = "src/lib.rs"
-
-
 rand = "0.8"
 rand_distr = "0.4"
-
-
-[[test]]
-name = "core_tests"
-path = "tests/black_scholes_tests.rs"

core/src/lib.rs

@@ -1,2 +1,12 @@
+//pub mod models {
+//    pub mod black_scholes;
+//    pub mod monte_carlo;
+//}
+//
+//pub mod strategies {
+//    pub mod butterfly;
+//    pub mod collar;
+//}
+
 pub mod models;
 pub mod strategies;

core/src/models/binomial.rs

@@ -1,35 +1,87 @@
 extern crate rand;
-use rand::Rng;
 use crate::models::OptionPricingModel;
+use rand::Rng;
 
+/// A Monte Carlo simulation model for option pricing.
 pub struct MonteCarloModel {
+    /// The number of simulations to run for estimating option prices.
     pub simulations: usize,
 }
 
 impl OptionPricingModel for MonteCarloModel {
+    /// Calculates the price of a European call option using Monte Carlo simulation.
+    ///
+    /// # Arguments
+    ///
+    /// * `s` - The current stock price.
+    /// * `k` - The strike price of the option.
+    /// * `r` - The risk-free interest rate (annualized).
+    /// * `sigma` - The volatility of the stock (annualized).
+    /// * `t` - The time to maturity in years.
+    ///
+    /// # Returns
+    ///
+    /// Returns the estimated price of the European call option.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let model = MonteCarloModel { simulations: 10000 };
+    /// let call_price = model.call_price(100.0, 100.0, 0.05, 0.2, 1.0);
+    /// println!("Call Price: {}", call_price);
+    /// ```
     fn call_price(&self, s: f64, k: f64, r: f64, sigma: f64, t: f64) -> f64 {
         let mut rng = rand::thread_rng();
         let mut payoff_sum = 0.0;
 
         for _ in 0..self.simulations {
+            // Generate a random sample from the standard normal distribution.
             let z: f64 = rng.sample(rand::distributions::StandardNormal);
+            // Calculate the simulated stock price at maturity.
             let st = s * ((r - 0.5 * sigma.powi(2)) * t + sigma * t.sqrt() * z).exp();
+            // Accumulate the payoff for the call option.
             payoff_sum += (st - k).max(0.0);
         }
 
+        // Discount the average payoff to present value.
         (payoff_sum / self.simulations as f64) * (-r * t).exp()
     }
 
+    /// Calculates the price of a European put option using Monte Carlo simulation.
+    ///
+    /// # Arguments
+    ///
+    /// * `s` - The current stock price.
+    /// * `k` - The strike price of the option.
+    /// * `r` - The risk-free interest rate (annualized).
+    /// * `sigma` - The volatility of the stock (annualized).
+    /// * `t` - The time to maturity in years.
+    ///
+    /// # Returns
+    ///
+    /// Returns the estimated price of the European put option.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let model = MonteCarloModel { simulations: 10000 };
+    /// let put_price = model.put_price(100.0, 100.0, 0.05, 0.2, 1.0);
+    /// println!("Put Price: {}", put_price);
+    /// ```
     fn put_price(&self, s: f64, k: f64, r: f64, sigma: f64, t: f64) -> f64 {
         let mut rng = rand::thread_rng();
         let mut payoff_sum = 0.0;
 
         for _ in 0..self.simulations {
+            // Generate a random sample from the standard normal distribution.
             let z: f64 = rng.sample(rand::distributions::StandardNormal);
+            // Calculate the simulated stock price at maturity.
             let st = s * ((r - 0.5 * sigma.powi(2)) * t + sigma * t.sqrt() * z).exp();
+            // Accumulate the payoff for the put option.
             payoff_sum += (k - st).max(0.0);
         }
 
+        // Discount the average payoff to present value.
         (payoff_sum / self.simulations as f64) * (-r * t).exp()
     }
 }