add equity futures

Author: siddharthqs

src/core/utils.rs

@@ -47,7 +47,9 @@ pub struct MarketData {
     pub maturity:String,
     pub dividend: Option<f64>,
     pub simulation:Option<u64>,
+    pub current_price:Option<f64>
 }
+
 #[derive(Clone,Debug,Deserialize,Serialize)]
 pub struct RateData {
     pub instrument: String,
@@ -66,6 +68,7 @@ pub struct Contract {
     pub action: String,
     pub pricer: String,
     pub asset: String,
+    pub product_type: Option<String>,
     pub payoff_type:Option<String>,
     pub style: Option<String>,
     pub market_data: Option<MarketData>,

src/equity/equity_future.rs

@@ -0,0 +1,62 @@
+// An equity
+use chrono::{Datelike, Local, NaiveDate};
+use crate::core::quotes::Quote;
+use crate::core::traits::Instrument;
+use crate::core::utils::{Contract,ContractStyle};
+use crate::equity::vanila_option::EquityOption;
+
+pub struct EquityFuture {
+    pub underlying_price: Quote,
+    pub current_price: Quote,
+    pub risk_free_rate: f64,
+    pub dividend_yield: f64,
+    pub maturity_date: NaiveDate,
+    pub valuation_date: NaiveDate,
+}
+
+impl EquityFuture {
+    pub fn from_json(data: &Contract) -> Box<Self> {
+        let market_data = data.market_data.as_ref().unwrap();
+        //let future_date = NaiveDate::parse_from_str(&maturity_date, "%Y-%m-%d").expect("Invalid date format");
+        let today = Local::today();
+        let maturity_date = NaiveDate::parse_from_str(&market_data.maturity, "%Y-%m-%d")
+            .expect("Invalid maturity date");
+
+        let underlying_quote = Quote::new(market_data.underlying_price);
+        let quote = Some(market_data.current_price).unwrap();
+        let current_quote = Quote::new(quote.unwrap_or(0.0));
+        let risk_free_rate = Some(market_data.risk_free_rate).unwrap();
+        let dividend = Some(market_data.dividend).unwrap();
+        Box::new(Self {
+            underlying_price: underlying_quote,
+            current_price:current_quote,
+            risk_free_rate: risk_free_rate.unwrap_or(0.0),
+            dividend_yield: dividend.unwrap_or(0.0),
+            maturity_date: maturity_date,
+            valuation_date: today.naive_utc(),
+        })
+    }
+
+    fn time_to_maturity(&self) -> f64 {
+        let days = (self.maturity_date - self.valuation_date).num_days();
+        (days as f64) / 365.0
+    }
+    fn premiun(&self)->f64{
+        self.current_price.value()-self.underlying_price.value()
+    }
+}
+impl Instrument for EquityFuture {
+    fn npv(&self) -> f64 {
+        // F_0 = S_0 * e^{(r - q)*t}
+        let t = self.time_to_maturity();
+        self.underlying_price.value() * ((self.risk_free_rate - self.dividend_yield) * t).exp()
+    }
+}
+impl EquityFuture{
+    pub fn delta(&self) -> f64 { 1.0 }
+    pub fn gamma(&self) -> f64 { 0.0 }
+    pub fn vega(&self) -> f64  { 0.0 }
+    pub fn theta(&self) -> f64 { 0.0 }
+    pub fn rho(&self) -> f64   { 0.0 }
+}
+// }

src/equity/handle_equity_contracts.rs

@@ -0,0 +1,48 @@
+use crate::core::traits::Instrument;
+use crate::core::utils::{Contract,CombinedContract, ContractOutput};
+use crate::equity::vanila_option::EquityOption;
+use crate::equity::equity_future::EquityFuture;
+pub fn handle_equity_contract(data: &Contract) -> String {
+    match data.product_type.as_deref() {
+        Some("Option") => {
+            let option = EquityOption::from_json(&data);
+            let contract_output = ContractOutput {
+                pv: option.npv(),
+                delta: option.delta(),
+                gamma: option.gamma(),
+                vega: option.vega(),
+                theta: option.theta(),
+                rho: option.rho(),
+                error: None
+            };
+            println!("Theoretical Price ${}", contract_output.pv);
+            println!("Delta ${}", contract_output.delta);
+            let combined_ = CombinedContract{
+                contract: data.clone(),
+                output:contract_output
+            };
+            serde_json::to_string(&combined_).expect("Failed to generate output")
+        }
+        Some("Future") => {
+            let future = EquityFuture::from_json(data);
+            let contract_output = ContractOutput {
+                pv: future.npv(),
+                delta: future.delta(),
+                gamma: future.gamma(),
+                vega: future.vega(),
+                theta: future.theta(),
+                rho: future.rho(),
+                error: None
+            };
+            println!("Equity Future Price: {}", contract_output.pv);
+            let combined_ = CombinedContract {
+                contract: data.clone(),
+                output: contract_output
+            };
+            serde_json::to_string(&combined_).expect("Failed to generate output")
+        }
+        _ => {
+            panic!("Unsupported or missing product_type for asset EQ");
+        }
+    }
+}

src/equity/mod.rs

@@ -8,3 +8,5 @@ pub mod build_contracts;
 pub mod vol_surface;
 pub mod finite_difference;
 pub mod binary_option;
+mod equity_future;
+pub mod handle_equity_contracts;

src/examples/EQ/equity_option.json

@@ -1,8 +1,10 @@
-{"contracts" : [
+{"asset":"EQ",
+  "contracts" : [
 {
   "action":"PV",
   "pricer":"Analytical",
   "asset":"EQ",
+  "product_type": "Option",
   "payoff_type": "Vanilla",
   "market_data":{
     "underlying_price":100,
@@ -18,12 +20,10 @@
     "action":"PV",
     "pricer":"Analytical",
     "asset":"EQ",
-    "payoff_type": "Vanilla",
+    "product_type": "Future",
     "market_data":{
       "underlying_price":100,
-      "option_type":"P",
-      "strike_price":100,
-      "volatility":0.4,
+      "current_price":104,
       "risk_free_rate":0.06,
       "maturity":"2025-03-31",
       "dividend": 0.01

src/utils/parse_json.rs

@@ -25,6 +25,8 @@ use crate::rates::deposits::Deposit;
 use crate::rates::build_contracts::{build_ir_contracts, build_ir_contracts_from_json, build_term_structure};
 use crate::equity::build_contracts::{build_eq_contracts_from_json};
 use crate::equity::vol_surface::VolSurface;
+use crate::equity::handle_equity_contracts::handle_equity_contract;
+
 use rayon::prelude::*;
 /// This function saves the output to a file and returns the path to the file.
 pub fn save_to_file<'a>(output_folder: &'a str, subfolder: &'a str, filename: &'a str, output: &'a str) -> String {
@@ -110,18 +112,8 @@ pub fn process_contract(data: &Contract) -> String {
     let ts = YieldTermStructure::new(date,rates);
 
     if data.action=="PV" && data.asset=="EQ"{
-        //let market_data = data.market_data.clone().unwrap();
-        let option = EquityOption::from_json(&data);
-        let contract_output = ContractOutput{pv:option.npv(),delta:option.delta(),gamma:option.gamma(),
-            vega:option.vega(),theta:option.theta(),rho:option.rho(), error: None };
-        println!("Theoretical Price ${}", contract_output.pv);
-        println!("Delta ${}", contract_output.delta);
-        let combined_ = CombinedContract{
-            contract: data.clone(),
-            output:contract_output
-        };
-        let output_json = serde_json::to_string(&combined_).expect("Failed to generate output");
-        return output_json;
+        return handle_equity_contract(data);
+
     }
     else if data.action=="PV" && data.asset=="CO"{
         let market_data = data.market_data.clone().unwrap();