8740953783

Committed 18 Apr 2024 03:49PM UTC coverage: 26.288% (+11.1%) from 15.157%

Build # 8740953783

Build Type

push

github

Committed by

danielhstahl

Commit Message

update hull white, make enum work

Run Details

96 of 673 branches covered (14.26%)

Branch coverage included in aggregate %.

28 of 60 new or added lines in 1 file covered. (46.67%)

12 existing lines in 1 file now uncovered.

149 of 259 relevant lines covered (57.53%)

80.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

26.29

/src/main.rs

use serde_derive::Deserialize;
use serde_enum_str::Deserialize_enum_str;
use serde_json::json;

use hull_white::HullWhite;
use lambda_http::{run, service_fn, Body, Error, Request, RequestExt, Response};

use rand::distributions::StandardNormal;
use rand::{thread_rng, Rng};
use rayon::prelude::*;
use std::collections::HashMap;
use std::f64;

fn build_response(code: u16, body: &str) -> Result<Response<Body>, Error> {
    Ok(Response::builder()
        .status(code)
        .header("Access-Control-Allow-Origin", "*")
        .header("Access-Control-Allow-Credentials", "true")
        .body::<Body>(body.into())?)
}
fn construct_error(e_message: &str) -> String {
    json!({ "err": e_message }).to_string()
}

fn yield_curve(curr_rate: f64, a: f64, b: f64, sig: f64) -> impl Fn(f64) -> f64 {
    move |t| {
        let at = (1.0 - (-a * t).exp()) / a;
        let ct =
            (b - sig.powi(2) / (2.0 * a.powi(2))) * (at - t) - sig.powi(2) * at.powi(2) / (4.0 * a);
        at * curr_rate - ct
    }
}
fn forward_curve(curr_rate: f64, a: f64, b: f64, sig: f64) -> impl Fn(f64) -> f64 {
    move |t| {
        let tmp = (-a * t).exp();
        b + tmp * (curr_rate - b) - (sig.powi(2) / (2.0 * a.powi(2))) * (1.0 - tmp).powi(2)
    }
}

fn generate_vasicek(curr_rate: f64, a: f64, b: f64, sig: f64, t: f64) -> impl Fn(f64) -> f64 {
    let tmp = (-a * t).exp();
    let mu = b * (1.0 - tmp) + curr_rate * tmp;
    let vol = sig * ((1.0 - (-2.0 * a * t).exp()) / (2.0 * a)).sqrt();
    move |random_number| mu + vol * random_number
}

const NUM_SIMS: usize = 500;

#[derive(Deserialize_enum_str, Debug)]
#[serde(rename_all = "lowercase")]
enum Asset {
    BOND,
    EDF,
    BONDCALL,
    BONDPUT,
    CAPLET,
    SWAP,
    SWAPTION,
    AMERICANSWAPTION,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BaseParameters {
    t: f64,
    r0: f64,
    a: f64,
    b: f64,
    sigma: f64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BondParameters {
    maturity: f64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct EDFParameters {
    maturity: f64,
    tenor: f64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BondOptionParameters {
    maturity: f64,
    underlying_maturity: f64,
    strike: f64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct CapletParameters {
    maturity: f64,
    tenor: f64,
    strike: f64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct SwapParameters {
    maturity: f64,
    tenor: f64,
    swap_rate: f64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct SwaptionParameters {
    maturity: f64,
    tenor: f64,
    num_swap_payments: usize,
    swap_rate: f64,
}

fn bin(min: f64, max: f64, num_bins: f64, elements: &[f64]) -> HashMap<String, usize> {
    let mut bins = HashMap::new();
    let range = max - min;
    let bin_width = range / num_bins;
    for element in elements.iter() {
        let key = if element == &max {
            format!("{:.4}-{:.4}", max - bin_width, max)
        } else {
            let lower_index = ((element - min) / bin_width).floor();
            let lower_bound = lower_index * bin_width + min;
            let upper_bound = (lower_index + 1.0) * bin_width + min;
            format!("{:.4}-{:.4}", lower_bound, upper_bound)
        };
        if let Some(x) = bins.get_mut(&key) {
            *x += 1;
        } else {
            bins.insert(key, 1);
        }
    }
    bins
}

const ONE_THIRD: f64 = 1.0 / 3.0;
fn combine_and_bin(min: f64, max: f64, elements: &[f64]) -> HashMap<String, usize> {
    let num_bins = (2.0 * (elements.len() as f64).powf(ONE_THIRD)).floor();
    bin(min, max, num_bins, elements)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let func = service_fn(func);
    run(func).await
}

async fn func(event: Request) -> Result<Response<Body>, Error> {
    match market_faas(event) {
        Ok(res) => Ok(build_response(200, &json!(res).to_string())?),
        Err(e) => Ok(build_response(400, &construct_error(&e.to_string()))?),
    }
}

fn mc_results<T>(num_sims: usize, func_to_sim: T) -> Vec<f64>
where
    T: Fn(f64) -> f64 + std::marker::Sync,
{
    let normal = StandardNormal;
    (0..num_sims)
        .into_par_iter()
        .map(|_index| {
            let norm = thread_rng().sample(normal);
            func_to_sim(norm)
        })
        .collect()
}

fn min_v(results: &[f64]) -> f64 {
    results.iter().fold(f64::INFINITY, |a, &b| a.min(b))
}
fn max_v(results: &[f64]) -> f64 {
    results.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b))
}

fn mc<T>(num_sims: usize, func_to_sim: T) -> HashMap<String, usize>
where
    T: Fn(f64) -> f64 + std::marker::Sync,
{
    let results = mc_results(num_sims, &func_to_sim);
    let min = min_v(&results);
    let max = max_v(&results);
    combine_and_bin(min, max, &results)
}

//simplistic, but good enough
fn transform_days_to_year(t: f64) -> f64 {
    t / 365.0
}

fn market_faas(event: Request) -> Result<HashMap<String, usize>, Box<dyn std::error::Error>> {
    let asset: Asset = event
        .path_parameters()
        .first("asset")
        .unwrap_or("bond")
        .parse::<Asset>()?;

    let BaseParameters { t, a, r0, b, sigma } = serde_json::from_reader(event.body().as_ref())?;
    let t = transform_days_to_year(t);
    let yield_fn = yield_curve(r0, a, b, sigma);
    let forward_fn = forward_curve(r0, a, b, sigma);
    let hull_white = HullWhite::init(a, sigma, &yield_fn, &forward_fn);
    let simulation = generate_vasicek(r0, a, b, sigma, t);
    match asset {
        Asset::BOND => {
            let BondParameters { maturity } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.bond_price_t(r_t, t, maturity)
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::EDF => {
            let EDFParameters { maturity, tenor } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.euro_dollar_future_t(r_t, t, maturity, tenor)
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::BONDCALL => {
            let BondOptionParameters {
                maturity,
                underlying_maturity,
                strike,
            } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.bond_call_t(r_t, t, maturity, underlying_maturity, strike)
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::BONDPUT => {
            let BondOptionParameters {
                maturity,
                underlying_maturity,
                strike,
            } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.bond_put_t(r_t, t, maturity, underlying_maturity, strike)
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::CAPLET => {
            let CapletParameters {
                maturity,
                strike,
                tenor,
            } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.caplet_t(r_t, t, maturity, tenor, strike)
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::SWAP => {
            let SwapParameters {
                maturity,
                swap_rate,
                tenor,
            } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.swap_price_t(r_t, t, maturity, tenor, swap_rate)
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::SWAPTION => {
            let SwaptionParameters {
                maturity,
                swap_rate,
                num_swap_payments,
                tenor,
            } = serde_json::from_reader(event.body().as_ref())?;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white
                    .european_payer_swaption_t(
                        r_t,
                        t,
                        maturity,
                        num_swap_payments,
                        tenor,
                        swap_rate,
                    )
                    .unwrap()
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
        Asset::AMERICANSWAPTION => {
            let SwaptionParameters {
                maturity,
                swap_rate,
                num_swap_payments,
                tenor,
            } = serde_json::from_reader(event.body().as_ref())?;
            let num_tree = 100;
            let func_to_sim = |random_number: f64| {
                let r_t = simulation(random_number);
                hull_white.american_payer_swaption_t(
                    r_t,
                    t,
                    maturity,
                    num_swap_payments,
                    tenor,
                    swap_rate,
                    num_tree,
                )
            };
            Ok(mc(NUM_SIMS, &func_to_sim))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_histogram() {
        let histogram = bin(5.0, 8.0, 2.0, &vec![5.0, 8.0, 7.0]);
        assert_eq!(histogram.contains_key("5.0000-6.5000"), true);
        assert_eq!(histogram.contains_key("6.5000-8.0000"), true);
        assert_eq!(histogram.get("5.0000-6.5000").unwrap(), &1);
        assert_eq!(histogram.get("6.5000-8.0000").unwrap(), &2);
    }
    #[test]
    fn test_histogram_edge() {
        let histogram = bin(5.0, 8.0, 2.0, &vec![5.0, 8.0, 6.5]);
        assert_eq!(histogram.contains_key("5.0000-6.5000"), true);
        assert_eq!(histogram.contains_key("6.5000-8.0000"), true);
        assert_eq!(histogram.get("5.0000-6.5000").unwrap(), &1);
        assert_eq!(histogram.get("6.5000-8.0000").unwrap(), &2);
    }
    #[test]
    fn test_histogram_edge_2() {
        let histogram = bin(5.0, 8.0, 2.0, &vec![5.0, 8.0, 6.499]);
        assert_eq!(histogram.contains_key("5.0000-6.5000"), true);
        assert_eq!(histogram.contains_key("6.5000-8.0000"), true);
        assert_eq!(histogram.get("5.0000-6.5000").unwrap(), &2);
        assert_eq!(histogram.get("6.5000-8.0000").unwrap(), &1);
    }
    #[test]
    fn vasicek_simulation() {
        let r = 0.04;
        let a = 0.3;
        let b = 0.05;
        let sig = 0.001; //to ensure not too great variability
        let t = 50.0;
        let simulation = generate_vasicek(r, a, b, sig, t);
        let n = 500;
        let results = mc_results(n, &simulation);
        let average_result = results.iter().fold(0.0, |a, b| a + b) / (n as f64);
        println!("this is average: {}", average_result);
        assert_eq!(average_result < 0.052, true);
        assert_eq!(average_result > 0.048, true);
    }
    #[tokio::test]
    async fn test_bond_simulation() {
        let input = include_str!("gateway_request.json");
        let request = lambda_http::request::from_str(&input).expect("failed to create request");
        let body = func(request).await.unwrap(); //.body();
        match &body.body() {
            Body::Text(text) => println!("{}", text),
            _ => println!("Not text"),
        }
        assert!(!body.body().is_empty());
    }

    /*#[test]
    fn bond_simulation() {
        let r = 0.04;
        let a = 0.3;
        let b = 0.05;
        let sig = 0.001; //to ensure not too great variability
        let t = transform_days_to_year(10.0);
        let maturity = 1.0;
        let simulation = generate_vasicek(r, a, b, sig, t);
        let yield_fn = yield_curve(r, a, b, sig);
        let forward_fn = forward_curve(r, a, b, sig);
        let func_to_sim = |random_number: f64| {
            let r_t = simulation(random_number);
            hull_white::bond_price_t(r_t, a, sig, t, maturity, &yield_fn, &forward_fn)
        };
        let n = 500;
        let results = mc_results(n, &func_to_sim);
        let average_result = results.iter().fold(0.0, |a, b| a + b) / (n as f64);
        println!("this is average: {}", average_result);
        assert_eq!(average_result < 0.961, true);
        assert_eq!(average_result > 0.960, true);
    }
    #[test]
    fn edf_simulation() {
        let r = 0.04;
        let a = 0.3;
        let b = 0.05;
        let sig = 0.001; //to ensure not too great variability
        let t = transform_days_to_year(10.0);
        let maturity = 1.0;
        let delta = 0.25;
        let simulation = generate_vasicek(r, a, b, sig, t);
        let yield_fn = yield_curve(r, a, b, sig);
        let forward_fn = forward_curve(r, a, b, sig);
        let func_to_sim = |random_number: f64| {
            let r_t = simulation(random_number);
            hull_white.euro_dollar_future_t(r_t, a, sig, t, maturity, delta, &yield_fn, &forward_fn)
        };
        let n = 500;
        let results = mc_results(n, &func_to_sim);
        let average_result = results.iter().fold(0.0, |a, b| a + b) / (n as f64);
        println!("this is average: {}", average_result);
        assert_eq!(average_result < 0.044, true);
        assert_eq!(average_result > 0.042, true);
    }
    #[test]
    fn bondcall_simulation() {
        let r = 0.04;
        let a = 0.3;
        let b = 0.05;
        let sig = 0.001; //to ensure not too great variability
        let t = transform_days_to_year(10.0);
        let maturity = 1.0;
        let bond_maturity = 1.25;
        let strike = 0.97;
        let simulation = generate_vasicek(r, a, b, sig, t);
        let yield_fn = yield_curve(r, a, b, sig);
        let forward_fn = forward_curve(r, a, b, sig);
        let func_to_sim = |random_number: f64| {
            let r_t = simulation(random_number);
            hull_white::bond_call_t(
                r_t,
                a,
                sig,
                t,
                maturity,
                bond_maturity,
                strike,
                &yield_fn,
                &forward_fn,
            )
        };
        let n = 500;
        let results = mc_results(n, &func_to_sim);
        let average_result = results.iter().fold(0.0, |a, b| a + b) / (n as f64);
        println!("this is average: {}", average_result);
        assert_eq!(average_result < 0.019, true);
        assert_eq!(average_result > 0.017, true);
    }
    #[test]
    fn bondput_simulation() {
        let r = 0.04;
        let a = 0.3;
        let b = 0.05;
        let sig = 0.001; //to ensure not too great variability
        let t = transform_days_to_year(10.0);
        let maturity = 1.0;
        let bond_maturity = 1.25;
        let strike = 0.995;
        let simulation = generate_vasicek(r, a, b, sig, t);
        let yield_fn = yield_curve(r, a, b, sig);
        let forward_fn = forward_curve(r, a, b, sig);
        let func_to_sim = |random_number: f64| {
            let r_t = simulation(random_number);
            hull_white::bond_put_t(
                r_t,
                a,
                sig,
                t,
                maturity,
                bond_maturity,
                strike,
                &yield_fn,
                &forward_fn,
            )
        };
        let n = 500;
        let results = mc_results(n, &func_to_sim);
        let average_result = results.iter().fold(0.0, |a, b| a + b) / (n as f64);
        println!("this is average: {}", average_result);
        assert_eq!(average_result < 0.006, true);
        assert_eq!(average_result > 0.005, true);
    }*/
    #[test]
    fn min_v_test() {
        let v = vec![4.0, 2.0, 5.0];
        let result = min_v(&v);
        assert_eq!(result, 2.0);
    }
    #[test]
    fn max_v_test() {
        let v = vec![4.0, 2.0, 5.0];
        let result = max_v(&v);
        assert_eq!(result, 5.0);
    }
}

1	use serde_derive::Deserialize;	8✔
2	use serde_enum_str::Deserialize_enum_str;
3	use serde_json::json;
4
5	use hull_white::HullWhite;
6	use lambda_http::{run, service_fn, Body, Error, Request, RequestExt, Response};
7
8	use rand::distributions::StandardNormal;
9	use rand::{thread_rng, Rng};
10	use rayon::prelude::*;
11	use std::collections::HashMap;
12	use std::f64;
13
14	fn build_response(code: u16, body: &str) -> Result<Response<Body>, Error> {	1✔
15	Ok(Response::builder()	2✔
16	.status(code)
17	.header("Access-Control-Allow-Origin", "*")
18	.header("Access-Control-Allow-Credentials", "true")
19	.body::<Body>(body.into())?)	1!
20	}	1✔
21	fn construct_error(e_message: &str) -> String {	×
22	json!({ "err": e_message }).to_string()	×
23	}	×
24
25	fn yield_curve(curr_rate: f64, a: f64, b: f64, sig: f64) -> impl Fn(f64) -> f64 {	1✔
26	move \|t\| {	958✔
27	let at = (1.0 - (-a * t).exp()) / a;	957✔
28	let ct =
29	(b - sig.powi(2) / (2.0 * a.powi(2))) * (at - t) - sig.powi(2) * at.powi(2) / (4.0 * a);	957✔
30	at * curr_rate - ct	957✔
31	}	957✔
32	}	1✔
33	fn forward_curve(curr_rate: f64, a: f64, b: f64, sig: f64) -> impl Fn(f64) -> f64 {	1✔
34	move \|t\| {	492✔
35	let tmp = (-a * t).exp();	491✔
36	b + tmp * (curr_rate - b) - (sig.powi(2) / (2.0 * a.powi(2))) * (1.0 - tmp).powi(2)	491✔
37	}	491✔
38	}	1✔
39
40	fn generate_vasicek(curr_rate: f64, a: f64, b: f64, sig: f64, t: f64) -> impl Fn(f64) -> f64 {	2✔
41	let tmp = (-a * t).exp();	2✔
42	let mu = b * (1.0 - tmp) + curr_rate * tmp;	2✔
43	let vol = sig * ((1.0 - (-2.0 * a * t).exp()) / (2.0 * a)).sqrt();	2✔
44	move \|random_number\| mu + vol * random_number	975✔
45	}	2✔
46
47	const NUM_SIMS: usize = 500;
48
49	#[derive(Deserialize_enum_str, Debug)]	9!
50	#[serde(rename_all = "lowercase")]
51	enum Asset {	2✔
52	BOND,
53	EDF,
54	BONDCALL,
55	BONDPUT,
56	CAPLET,
57	SWAP,
58	SWAPTION,
59	AMERICANSWAPTION,
60	}
61
62	#[derive(Debug, Deserialize)]	20!
63	#[serde(rename_all = "camelCase")]
64	struct BaseParameters {
65	t: f64,
66	r0: f64,	×
67	a: f64,	×
68	b: f64,	×
69	sigma: f64,	×
70	}
71
72	#[derive(Debug, Deserialize)]	20!
73	#[serde(rename_all = "camelCase")]
74	struct BondParameters {
UNCOV 75	maturity: f64,	×
76	}
77
78	#[derive(Debug, Deserialize)]	×
79	#[serde(rename_all = "camelCase")]
80	struct EDFParameters {
81	maturity: f64,
82	tenor: f64,	×
83	}
84
85	#[derive(Debug, Deserialize)]	×
86	#[serde(rename_all = "camelCase")]
87	struct BondOptionParameters {
88	maturity: f64,
89	underlying_maturity: f64,	×
90	strike: f64,	×
91	}
92
93	#[derive(Debug, Deserialize)]	×
94	#[serde(rename_all = "camelCase")]
95	struct CapletParameters {
96	maturity: f64,
97	tenor: f64,	×
98	strike: f64,	×
99	}
100
101	#[derive(Debug, Deserialize)]	×
102	#[serde(rename_all = "camelCase")]
103	struct SwapParameters {
104	maturity: f64,
105	tenor: f64,	×
106	swap_rate: f64,	×
107	}
108
109	#[derive(Debug, Deserialize)]	×
110	#[serde(rename_all = "camelCase")]
111	struct SwaptionParameters {
112	maturity: f64,
113	tenor: f64,	×
NEW 114	num_swap_payments: usize,	×
115	swap_rate: f64,	×
116	}
117
118	fn bin(min: f64, max: f64, num_bins: f64, elements: &[f64]) -> HashMap<String, usize> {	4✔
119	let mut bins = HashMap::new();	4✔
120	let range = max - min;	4✔
121	let bin_width = range / num_bins;	4✔
122	for element in elements.iter() {	513✔
123	let key = if element == &max {	509✔
124	format!("{:.4}-{:.4}", max - bin_width, max)	4✔
125	} else {
126	let lower_index = ((element - min) / bin_width).floor();	505✔
127	let lower_bound = lower_index * bin_width + min;	505✔
128	let upper_bound = (lower_index + 1.0) * bin_width + min;	505✔
129	format!("{:.4}-{:.4}", lower_bound, upper_bound)	505✔
130	};
131	if let Some(x) = bins.get_mut(&key) {	509✔
132	*x += 1;	488✔
133	} else {
134	bins.insert(key, 1);	21✔
135	}
136	}	509✔
137	bins	4✔
138	}	4✔
139
140	const ONE_THIRD: f64 = 1.0 / 3.0;
141	fn combine_and_bin(min: f64, max: f64, elements: &[f64]) -> HashMap<String, usize> {	1✔
142	let num_bins = (2.0 * (elements.len() as f64).powf(ONE_THIRD)).floor();	1✔
143	bin(min, max, num_bins, elements)	1✔
144	}	1✔
145
NEW 146	#[tokio::main]	×
NEW 147	async fn main() -> Result<(), Error> {	×
NEW 148	let func = service_fn(func);	×
NEW 149	run(func).await	×
150	}	×
151
152	async fn func(event: Request) -> Result<Response<Body>, Error> {	2!
153	match market_faas(event) {	1!
154	Ok(res) => Ok(build_response(200, &json!(res).to_string())?),	1!
NEW 155	Err(e) => Ok(build_response(400, &construct_error(&e.to_string()))?),	×
156	}
157	}	2✔
158
159	fn mc_results<T>(num_sims: usize, func_to_sim: T) -> Vec<f64>	2✔
160	where
161	T: Fn(f64) -> f64 + std::marker::Sync,
162	{
163	let normal = StandardNormal;	967✔
164	(0..num_sims)	4✔
165	.into_par_iter()
166	.map(\|_index\| {	967✔
167	let norm = thread_rng().sample(normal);	965✔
168	func_to_sim(norm)	965✔
169	})	965✔
170	.collect()
171	}	2✔
172
173	fn min_v(results: &[f64]) -> f64 {	2✔
174	results.iter().fold(f64::INFINITY, \|a, &b\| a.min(b))	505✔
175	}	2✔
176	fn max_v(results: &[f64]) -> f64 {	2✔
177	results.iter().fold(f64::NEG_INFINITY, \|a, &b\| a.max(b))	505✔
178	}	2✔
179
180	fn mc<T>(num_sims: usize, func_to_sim: T) -> HashMap<String, usize>	1✔
181	where
182	T: Fn(f64) -> f64 + std::marker::Sync,
183	{
184	let results = mc_results(num_sims, &func_to_sim);	1✔
185	let min = min_v(&results);	1✔
186	let max = max_v(&results);	1✔
187	combine_and_bin(min, max, &results)	1✔
188	}	1✔
189
190	//simplistic, but good enough
191	fn transform_days_to_year(t: f64) -> f64 {	1✔
192	t / 365.0	1✔
193	}	1✔
194
195	fn market_faas(event: Request) -> Result<HashMap<String, usize>, Box<dyn std::error::Error>> {	1✔
196	let asset: Asset = event	1✔
197	.path_parameters()
198	.first("asset")
199	.unwrap_or("bond")
200	.parse::<Asset>()?;	1✔
201
202	let BaseParameters { t, a, r0, b, sigma } = serde_json::from_reader(event.body().as_ref())?;	1!
203	let t = transform_days_to_year(t);	1✔
204	let yield_fn = yield_curve(r0, a, b, sigma);	1✔
205	let forward_fn = forward_curve(r0, a, b, sigma);	1✔
206	let hull_white = HullWhite::init(a, sigma, &yield_fn, &forward_fn);	1✔
207	let simulation = generate_vasicek(r0, a, b, sigma, t);	1✔
208	match asset {	1!
209	Asset::BOND => {
210	let BondParameters { maturity } = serde_json::from_reader(event.body().as_ref())?;	1!
211	let func_to_sim = \|random_number: f64\| {	477✔
212	let r_t = simulation(random_number);	476✔
213	hull_white.bond_price_t(r_t, t, maturity)	476✔
214	};	476✔
215	Ok(mc(NUM_SIMS, &func_to_sim))	1✔
216	}	1✔
217	Asset::EDF => {
NEW 218	let EDFParameters { maturity, tenor } = serde_json::from_reader(event.body().as_ref())?;	×
NEW 219	let func_to_sim = \|random_number: f64\| {	×
NEW 220	let r_t = simulation(random_number);	×
NEW 221	hull_white.euro_dollar_future_t(r_t, t, maturity, tenor)	×
222	};	×
NEW 223	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 224	}	×
225	Asset::BONDCALL => {
226	let BondOptionParameters {
227	maturity,	×
228	underlying_maturity,	×
229	strike,	×
230	} = serde_json::from_reader(event.body().as_ref())?;	×
231	let func_to_sim = \|random_number: f64\| {	×
232	let r_t = simulation(random_number);	×
NEW 233	hull_white.bond_call_t(r_t, t, maturity, underlying_maturity, strike)	×
UNCOV 234	};	×
NEW 235	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 236	}	×
237	Asset::BONDPUT => {
238	let BondOptionParameters {
239	maturity,	×
240	underlying_maturity,	×
241	strike,	×
242	} = serde_json::from_reader(event.body().as_ref())?;	×
243	let func_to_sim = \|random_number: f64\| {	×
244	let r_t = simulation(random_number);	×
NEW 245	hull_white.bond_put_t(r_t, t, maturity, underlying_maturity, strike)	×
UNCOV 246	};	×
NEW 247	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 248	}	×
249	Asset::CAPLET => {
250	let CapletParameters {
251	maturity,	×
252	strike,	×
253	tenor,	×
254	} = serde_json::from_reader(event.body().as_ref())?;	×
255	let func_to_sim = \|random_number: f64\| {	×
256	let r_t = simulation(random_number);	×
NEW 257	hull_white.caplet_t(r_t, t, maturity, tenor, strike)	×
UNCOV 258	};	×
NEW 259	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 260	}	×
261	Asset::SWAP => {
262	let SwapParameters {
263	maturity,	×
264	swap_rate,	×
265	tenor,	×
266	} = serde_json::from_reader(event.body().as_ref())?;	×
267	let func_to_sim = \|random_number: f64\| {	×
268	let r_t = simulation(random_number);	×
NEW 269	hull_white.swap_price_t(r_t, t, maturity, tenor, swap_rate)	×
UNCOV 270	};	×
NEW 271	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 272	}	×
273	Asset::SWAPTION => {
274	let SwaptionParameters {
275	maturity,	×
276	swap_rate,	×
NEW 277	num_swap_payments,	×
278	tenor,	×
279	} = serde_json::from_reader(event.body().as_ref())?;	×
280	let func_to_sim = \|random_number: f64\| {	×
281	let r_t = simulation(random_number);	×
NEW 282	hull_white	×
283	.european_payer_swaption_t(
284	r_t,
NEW 285	t,	×
NEW 286	maturity,	×
NEW 287	num_swap_payments,	×
NEW 288	tenor,	×
NEW 289	swap_rate,	×
290	)
291	.unwrap()
292	};	×
NEW 293	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 294	}	×
295	Asset::AMERICANSWAPTION => {
296	let SwaptionParameters {
297	maturity,	×
298	swap_rate,	×
NEW 299	num_swap_payments,	×
300	tenor,	×
301	} = serde_json::from_reader(event.body().as_ref())?;	×
302	let num_tree = 100;	1!
303	let func_to_sim = \|random_number: f64\| {	×
304	let r_t = simulation(random_number);	×
NEW 305	hull_white.american_payer_swaption_t(	×
306	r_t,
307	t,	×
308	maturity,	×
NEW 309	num_swap_payments,	×
310	tenor,	×
311	swap_rate,	×
312	num_tree,	×
313	)
314	};	×
NEW 315	Ok(mc(NUM_SIMS, &func_to_sim))	×
UNCOV 316	}	×
317	}
318	}	1✔
319
320	#[cfg(test)]
321	mod tests {
322	use super::*;
323	#[test]
324	fn test_histogram() {	2✔
325	let histogram = bin(5.0, 8.0, 2.0, &vec![5.0, 8.0, 7.0]);	1!
326	assert_eq!(histogram.contains_key("5.0000-6.5000"), true);	1!
327	assert_eq!(histogram.contains_key("6.5000-8.0000"), true);	1!
328	assert_eq!(histogram.get("5.0000-6.5000").unwrap(), &1);	1!
329	assert_eq!(histogram.get("6.5000-8.0000").unwrap(), &2);	1!
330	}	2✔
331	#[test]
332	fn test_histogram_edge() {	2✔
333	let histogram = bin(5.0, 8.0, 2.0, &vec![5.0, 8.0, 6.5]);	1!
334	assert_eq!(histogram.contains_key("5.0000-6.5000"), true);	1!
335	assert_eq!(histogram.contains_key("6.5000-8.0000"), true);	1!
336	assert_eq!(histogram.get("5.0000-6.5000").unwrap(), &1);	1!
337	assert_eq!(histogram.get("6.5000-8.0000").unwrap(), &2);	1!
338	}	2✔
339	#[test]
340	fn test_histogram_edge_2() {	2✔
341	let histogram = bin(5.0, 8.0, 2.0, &vec![5.0, 8.0, 6.499]);	1!
342	assert_eq!(histogram.contains_key("5.0000-6.5000"), true);	1!
343	assert_eq!(histogram.contains_key("6.5000-8.0000"), true);	1!
344	assert_eq!(histogram.get("5.0000-6.5000").unwrap(), &2);	1!
345	assert_eq!(histogram.get("6.5000-8.0000").unwrap(), &1);	1!
346	}	2✔
347	#[test]
348	fn vasicek_simulation() {	2✔
349	let r = 0.04;	1✔
350	let a = 0.3;	1✔
351	let b = 0.05;	1✔
352	let sig = 0.001; //to ensure not too great variability	1✔
353	let t = 50.0;	1✔
354	let simulation = generate_vasicek(r, a, b, sig, t);	1✔
355	let n = 500;	1✔
356	let results = mc_results(n, &simulation);	1✔
357	let average_result = results.iter().fold(0.0, \|a, b\| a + b) / (n as f64);	501✔
358	println!("this is average: {}", average_result);	1✔
359	assert_eq!(average_result < 0.052, true);	1!
360	assert_eq!(average_result > 0.048, true);	1!
361	}	2✔
362	#[tokio::test]	3!
363	async fn test_bond_simulation() {	2✔
364	let input = include_str!("gateway_request.json");	1✔
365	let request = lambda_http::request::from_str(&input).expect("failed to create request");	1✔
366	let body = func(request).await.unwrap(); //.body();	1!
367	match &body.body() {	2!
368	Body::Text(text) => println!("{}", text),	1✔
NEW 369	_ => println!("Not text"),	×
370	}
371	assert!(!body.body().is_empty());	2!
372	}	3✔
373
374	/*#[test]
375	fn bond_simulation() {
376	let r = 0.04;
377	let a = 0.3;
378	let b = 0.05;
379	let sig = 0.001; //to ensure not too great variability
380	let t = transform_days_to_year(10.0);
381	let maturity = 1.0;
382	let simulation = generate_vasicek(r, a, b, sig, t);
383	let yield_fn = yield_curve(r, a, b, sig);
384	let forward_fn = forward_curve(r, a, b, sig);
385	let func_to_sim = \|random_number: f64\| {
386	let r_t = simulation(random_number);
387	hull_white::bond_price_t(r_t, a, sig, t, maturity, &yield_fn, &forward_fn)
388	};
389	let n = 500;
390	let results = mc_results(n, &func_to_sim);
391	let average_result = results.iter().fold(0.0, \|a, b\| a + b) / (n as f64);
392	println!("this is average: {}", average_result);
393	assert_eq!(average_result < 0.961, true);
394	assert_eq!(average_result > 0.960, true);
395	}
396	#[test]
397	fn edf_simulation() {
398	let r = 0.04;
399	let a = 0.3;
400	let b = 0.05;
401	let sig = 0.001; //to ensure not too great variability
402	let t = transform_days_to_year(10.0);
403	let maturity = 1.0;
404	let delta = 0.25;
405	let simulation = generate_vasicek(r, a, b, sig, t);
406	let yield_fn = yield_curve(r, a, b, sig);
407	let forward_fn = forward_curve(r, a, b, sig);
408	let func_to_sim = \|random_number: f64\| {
409	let r_t = simulation(random_number);
410	hull_white.euro_dollar_future_t(r_t, a, sig, t, maturity, delta, &yield_fn, &forward_fn)
411	};
412	let n = 500;
413	let results = mc_results(n, &func_to_sim);
414	let average_result = results.iter().fold(0.0, \|a, b\| a + b) / (n as f64);
415	println!("this is average: {}", average_result);
416	assert_eq!(average_result < 0.044, true);
417	assert_eq!(average_result > 0.042, true);
418	}
419	#[test]
420	fn bondcall_simulation() {
421	let r = 0.04;
422	let a = 0.3;
423	let b = 0.05;
424	let sig = 0.001; //to ensure not too great variability
425	let t = transform_days_to_year(10.0);
426	let maturity = 1.0;
427	let bond_maturity = 1.25;
428	let strike = 0.97;
429	let simulation = generate_vasicek(r, a, b, sig, t);
430	let yield_fn = yield_curve(r, a, b, sig);
431	let forward_fn = forward_curve(r, a, b, sig);
432	let func_to_sim = \|random_number: f64\| {
433	let r_t = simulation(random_number);
434	hull_white::bond_call_t(
435	r_t,
436	a,
437	sig,
438	t,
439	maturity,
440	bond_maturity,
441	strike,
442	&yield_fn,
443	&forward_fn,
444	)
445	};
446	let n = 500;
447	let results = mc_results(n, &func_to_sim);
448	let average_result = results.iter().fold(0.0, \|a, b\| a + b) / (n as f64);
449	println!("this is average: {}", average_result);
450	assert_eq!(average_result < 0.019, true);
451	assert_eq!(average_result > 0.017, true);
452	}
453	#[test]
454	fn bondput_simulation() {
455	let r = 0.04;
456	let a = 0.3;
457	let b = 0.05;
458	let sig = 0.001; //to ensure not too great variability
459	let t = transform_days_to_year(10.0);
460	let maturity = 1.0;
461	let bond_maturity = 1.25;
462	let strike = 0.995;
463	let simulation = generate_vasicek(r, a, b, sig, t);
464	let yield_fn = yield_curve(r, a, b, sig);
465	let forward_fn = forward_curve(r, a, b, sig);
466	let func_to_sim = \|random_number: f64\| {
467	let r_t = simulation(random_number);
468	hull_white::bond_put_t(
469	r_t,
470	a,
471	sig,
472	t,
473	maturity,
474	bond_maturity,
475	strike,
476	&yield_fn,
477	&forward_fn,
478	)
479	};
480	let n = 500;
481	let results = mc_results(n, &func_to_sim);
482	let average_result = results.iter().fold(0.0, \|a, b\| a + b) / (n as f64);
483	println!("this is average: {}", average_result);
484	assert_eq!(average_result < 0.006, true);
485	assert_eq!(average_result > 0.005, true);
486	}*/
487	#[test]
488	fn min_v_test() {	2✔
489	let v = vec![4.0, 2.0, 5.0];	1!
490	let result = min_v(&v);	1✔
491	assert_eq!(result, 2.0);	1!
492	}	2✔
493	#[test]
494	fn max_v_test() {	2✔
495	let v = vec![4.0, 2.0, 5.0];	1!
496	let result = max_v(&v);	1✔
497	assert_eq!(result, 5.0);	1!
498	}	2✔
499	}

danielhstahl / market_faas / 8740953783

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous