RustQuant_instruments 0.3.1

A Rust library for quantitative finance.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// RustQuant: A Rust library for quantitative finance tools.
// Copyright (C) 2023 https://github.com/avhz
// Dual licensed under Apache 2.0 and MIT.
// See:
//      - LICENSE-APACHE.md
//      - LICENSE-MIT.md
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//! Monte-Carlo pricer trait.

use crate::Payoff;
use RustQuant_stochastics::{StochasticProcess, StochasticProcessConfig};

/// Monte-Carlo pricer trait.
pub trait MonteCarloPricer<S>: Payoff
where
    S: StochasticProcess,
{
    /// Price the instrument using a Monte-Carlo method.
    ///
    /// # Arguments
    ///
    /// * `process` - The [StochasticProcess] to use for the sample paths.
    /// * `config` - The [StochasticProcessConfig] for the simulation.
    /// * `rate` - The interest rate used to discount the payoff.
    fn price_monte_carlo(&self, process: &S, config: &StochasticProcessConfig, rate: f64) -> f64;
}

/// Macro to implement `MonteCarloPricer` for a given instrument type.
#[macro_export]
macro_rules! impl_monte_carlo_pricer {
    ($type:ty, $underlying:expr) => {
        impl<S> MonteCarloPricer<S> for $type
        where
            S: StochasticProcess,
        {
            fn price_monte_carlo(
                &self,
                process: &S,
                config: &StochasticProcessConfig,
                rate: f64,
            ) -> f64 {
                let out = process.euler_maruyama(&config);

                let n = out.paths.len();

                let df = (-rate * (config.t_n - config.t_0)).exp();

                let payoffs = out.paths.iter().fold(0.0, |acc, path| {
                    let underlying = $underlying(&*path);
                    let payoff = self.payoff(underlying);

                    acc + payoff
                });

                df * payoffs / n as f64
            }
        }
    };
}

fn path_independent(path: &[f64]) -> f64 {
    path.last().cloned().unwrap_or(0.0)
}

fn path_dependent(path: &[f64]) -> Vec<f64> {
    path.to_vec()
}

impl_monte_carlo_pricer!(crate::AsianOption, path_dependent);
impl_monte_carlo_pricer!(crate::BinaryOption, path_independent);
impl_monte_carlo_pricer!(crate::EuropeanVanillaOption, path_independent);
impl_monte_carlo_pricer!(crate::PowerContract, path_independent);
impl_monte_carlo_pricer!(crate::PowerOption, path_independent);
impl_monte_carlo_pricer!(crate::SupershareOption, path_independent);
impl_monte_carlo_pricer!(crate::BarrierOption, path_dependent);
impl_monte_carlo_pricer!(crate::CappedPowerOption, path_independent);
impl_monte_carlo_pricer!(crate::PoweredOption, path_independent);
impl_monte_carlo_pricer!(crate::LogMoneynessContract, path_independent);
impl_monte_carlo_pricer!(crate::LogUnderlyingContract, path_independent);
impl_monte_carlo_pricer!(crate::LogOption, path_independent);