optionstratlib 0.16.2

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use criterion::Criterion;
use optionstratlib::ExpirationDate;
use optionstratlib::chains::OptionData;
use optionstratlib::chains::utils::OptionDataPriceParams;
use positive::{Positive, pos_or_panic, spos};
use rust_decimal_macros::dec;
use std::hint::black_box;

pub fn benchmark_option_data(c: &mut Criterion) {
    let mut group = c.benchmark_group("OptionData Operations");

    // Basic operations benchmarks
    benchmark_basic_operations(&mut group);

    // Price calculation benchmarks with different parameters
    benchmark_price_calculations(&mut group);

    // Complex operations benchmarks
    benchmark_complex_operations(&mut group);

    group.finish();
}

fn benchmark_basic_operations(
    group: &mut criterion::BenchmarkGroup<'_, criterion::measurement::WallTime>,
) {
    // Benchmark creation with minimal data
    group.bench_function("create minimal option data", |b| {
        b.iter(|| {
            let option_data = OptionData::new(
                black_box(Positive::new(100.0).unwrap()),
                None,
                None,
                None,
                None,
                Positive::new(0.2).unwrap(),
                None,
                None,
                None,
                None,
                None,
                Some("TEST".to_string()),                        // symbol
                Some(ExpirationDate::Days(pos_or_panic!(30.0))), // expiration_date
                Some(Box::new(Positive::HUNDRED)),               // underlying_price
                Some(dec!(0.05)),                                // risk_free_rate
                Some(pos_or_panic!(0.02)),                       // dividend_yield
                None,
                None,
            );
            black_box(option_data)
        })
    });

    // Benchmark creation with full data
    group.bench_function("create full option data", |b| {
        b.iter(|| {
            let option_data = OptionData::new(
                black_box(Positive::new(100.0).unwrap()),
                Some(Positive::new(10.0).unwrap()),
                Some(Positive::new(11.0).unwrap()),
                Some(Positive::new(9.0).unwrap()),
                Some(Positive::new(10.0).unwrap()),
                Positive::new(0.2).unwrap(),
                Some(dec!(0.5)),
                Some(dec!(0.5)),
                Some(dec!(0.5)),
                Some(Positive::new(1000.0).unwrap()),
                Some(100),
                Some("TEST".to_string()),                        // symbol
                Some(ExpirationDate::Days(pos_or_panic!(30.0))), // expiration_date
                Some(Box::new(Positive::HUNDRED)),               // underlying_price
                Some(dec!(0.05)),                                // risk_free_rate
                Some(pos_or_panic!(0.02)),                       // dividend_yield
                None,
                None,
            );
            black_box(option_data)
        })
    });

    let option_data = create_test_option_data();
    group.bench_function("validate option data", |b| {
        b.iter(|| black_box(option_data.validate()))
    });
}

fn benchmark_price_calculations(
    group: &mut criterion::BenchmarkGroup<'_, criterion::measurement::WallTime>,
) {
    let option_data = create_test_option_data();

    // Standard price calculation
    let _standard_params = create_standard_price_params();
    group.bench_function("calculate standard prices", |b| {
        b.iter(|| {
            let mut data = option_data.clone();
            black_box(data.calculate_prices(None))
        })
    });
}

fn benchmark_complex_operations(
    group: &mut criterion::BenchmarkGroup<'_, criterion::measurement::WallTime>,
) {
    let option_data = create_test_option_data();

    // Combined operations benchmark
    group.bench_function("complete option processing", |b| {
        b.iter(|| {
            let mut data = option_data.clone();
            black_box(data.validate());
            let _ = black_box(data.calculate_prices(None));
            black_box(data)
        })
    });

    // Simulated large chain processing
    let chain_data: Vec<OptionData> = (0..50).map(|_| create_test_option_data()).collect();
    group.bench_function("process 50 option data items", |b| {
        b.iter(|| {
            let mut processed = chain_data.clone();
            for item in processed.iter_mut() {
                let _ = black_box(item.calculate_prices(None));
            }
            black_box(processed)
        })
    });
}

// Helper functions to create test data
fn create_test_option_data() -> OptionData {
    OptionData::new(
        Positive::new(100.0).unwrap(),
        Some(Positive::new(10.0).unwrap()),
        Some(Positive::new(11.0).unwrap()),
        Some(Positive::new(9.0).unwrap()),
        Some(Positive::new(10.0).unwrap()),
        Positive::new(0.2).unwrap(),
        Some(dec!(0.5)),
        None,
        None,
        None,
        None,
        Some("TEST".to_string()),                        // symbol
        Some(ExpirationDate::Days(pos_or_panic!(30.0))), // expiration_date
        Some(Box::new(Positive::HUNDRED)),               // underlying_price
        Some(dec!(0.05)),                                // risk_free_rate
        Some(pos_or_panic!(0.02)),                       // dividend_yield
        None,
        None,
    )
}

fn create_standard_price_params() -> OptionDataPriceParams {
    OptionDataPriceParams::new(
        Some(Box::new(Positive::HUNDRED)),
        Some(ExpirationDate::Days(pos_or_panic!(30.0))),
        Some(dec!(0.05)),
        spos!(0.02),
        Some("AAPL".to_string()),
    )
}