optionstratlib 0.18.0

OptionStratLib is a comprehensive Rust library for options trading and strategy development across multiple asset classes.
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

/******************************************************************************
   Author: Joaquín Béjar García
   Email: jb@taunais.com
   Date: 12/7/26
******************************************************************************/
//! Deterministic walkers for generator tests.
//!
//! `RampWalker` replaces the RNG-driven default walk methods with a fixed
//! arithmetic ramp so multi-step generator tests can assert exact prices,
//! indices and dates without seeds or wall-clock dependence.

use crate::error::SimulationError;
use crate::simulation::{WalkParams, WalkTypeAble};
use positive::Positive;
use std::convert::TryInto;
use std::fmt::Display;
use std::ops::AddAssign;

/// Test walker producing the deterministic ramp
/// `start, start + delta, start + 2·delta, …` (length `params.size`) for
/// every synthetic walk type. `Historical` keeps the default trait behavior
/// (slice of the provided prices) so its data-validation semantics stay
/// testable.
#[derive(Clone)]
pub(crate) struct RampWalker {
    /// Price increment per step.
    pub delta: Positive,
}

impl RampWalker {
    fn ramp<X, Y>(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError>
    where
        X: Copy + TryInto<Positive> + AddAssign + Display,
        Y: TryInto<Positive> + Display + Clone,
    {
        let start = params.ystep_as_positive()?;
        Ok((0..params.size)
            .map(|i| start + self.delta * i as f64)
            .collect())
    }
}

impl<X, Y> WalkTypeAble<X, Y> for RampWalker
where
    X: Copy + TryInto<Positive> + AddAssign + Display,
    Y: TryInto<Positive> + Display + Clone,
{
    fn brownian(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn geometric_brownian(
        &self,
        params: &WalkParams<X, Y>,
    ) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn log_returns(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn mean_reverting(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn jump_diffusion(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn garch(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn heston(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn custom(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }

    fn telegraph(&self, params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        self.ramp(params)
    }
}

/// Test walker whose every walk method returns an empty path, for pinning
/// the empty-output contract of the generators.
#[derive(Clone)]
pub(crate) struct EmptyWalker;

impl<X, Y> WalkTypeAble<X, Y> for EmptyWalker
where
    X: Copy + TryInto<Positive> + AddAssign + Display,
    Y: TryInto<Positive> + Display + Clone,
{
    fn brownian(&self, _params: &WalkParams<X, Y>) -> Result<Vec<Positive>, SimulationError> {
        Ok(Vec::new())
    }

    fn geometric_brownian(
        &self,
        _params: &WalkParams<X, Y>,
    ) -> Result<Vec<Positive>, SimulationError> {
        Ok(Vec::new())
    }
}