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

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 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
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

use derive_builder::Builder;

use super::option_flags::*;
use super::{AveragingMethod, OptionContract};
use crate::Payoff;

/// Asian option.
#[derive(Debug, Clone, Builder)]
pub struct AsianOption {
    /// The option contract.
    pub contract: OptionContract,

    /// Averging method (arithmetic or geometric).
    pub averaging_method: AveragingMethod,

    /// Strike price of the option.
    /// Required for fixed strike Asian options.
    pub strike: Option<f64>,
}

impl AsianOption {
    /// Create a new Asian option.
    pub fn new(
        contract: OptionContract,
        averaging_method: AveragingMethod,
        strike: Option<f64>,
    ) -> Self {
        Self {
            contract,
            averaging_method,
            strike,
        }
    }
}

impl Payoff for AsianOption {
    type Underlying = Vec<f64>;

    fn payoff(&self, underlying: Self::Underlying) -> f64 {
        let n = underlying.len();
        let path = underlying.iter();
        let terminal = underlying[n - 1];

        let average = match self.averaging_method {
            AveragingMethod::ArithmeticDiscrete => path.sum::<f64>() / n as f64,
            AveragingMethod::GeometricDiscrete => path.product::<f64>().powf(1.0 / n as f64),

            // Continuous averaging (i.e. integral of the path).
            _ => panic!("Continuous averaging not implemented."),
        };

        match self.contract.strike_flag {
            Some(StrikeFlag::Fixed) => match self.contract.type_flag {
                TypeFlag::Call => (average - self.strike.unwrap_or_default()).max(0.0),
                TypeFlag::Put => (self.strike.unwrap_or_default() - average).max(0.0),
            },
            Some(StrikeFlag::Floating) => match self.contract.type_flag {
                TypeFlag::Call => (terminal - average).max(0.0),
                TypeFlag::Put => (average - terminal).max(0.0),
            },
            None => panic!("Strike flag not set."),
        }
    }
}