optionstratlib 0.18.1

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

/******************************************************************************
   Author: Joaquín Béjar García
   Email: jb@taunais.com
   Date: 7/1/25
******************************************************************************/

use chrono::Utc;
use criterion::{Criterion, criterion_group, criterion_main};
use optionstratlib::model::Position;
use optionstratlib::pnl::utils::PnLCalculator;
use optionstratlib::{ExpirationDate, OptionStyle, OptionType, Options, Side};
use positive::{Positive, pos_or_panic};
use rust_decimal_macros::dec;
use std::hint::black_box;

fn create_test_option() -> Options {
    Options::new(
        OptionType::European,
        Side::Long,
        "AAPL".to_string(),
        Positive::HUNDRED,
        ExpirationDate::Days(pos_or_panic!(30.0)),
        pos_or_panic!(0.2),
        Positive::ONE,
        Positive::HUNDRED,
        dec!(0.05),
        OptionStyle::Call,
        pos_or_panic!(0.01),
        None,
    )
}

fn create_test_position() -> Position {
    Position::new(
        create_test_option(),
        pos_or_panic!(5.0), // premium
        Utc::now(),         // date
        pos_or_panic!(0.5), // open_fee
        pos_or_panic!(0.5), // close_fee
        None,
        None,
    )
}

pub(crate) fn benchmark_costs_and_fees(c: &mut Criterion) {
    let mut group = c.benchmark_group("Position Costs and Fees");
    let position = create_test_position();

    group.bench_function("total_cost", |bencher| {
        bencher.iter(|| black_box(position.total_cost()))
    });

    group.bench_function("premium_received", |bencher| {
        bencher.iter(|| black_box(position.premium_received()))
    });

    group.bench_function("net_premium_received", |bencher| {
        bencher.iter(|| black_box(position.net_premium_received()))
    });

    group.bench_function("fees", |bencher| {
        bencher.iter(|| black_box(position.fees()))
    });

    group.bench_function("net_cost", |bencher| {
        bencher.iter(|| black_box(position.net_cost()))
    });

    group.finish();
}

pub(crate) fn benchmark_profit_calculations(c: &mut Criterion) {
    let mut group = c.benchmark_group("Position Profit Calculations");
    let position = create_test_position();
    let test_price = pos_or_panic!(110.0);

    group.bench_function("break_even", |bencher| {
        bencher.iter(|| black_box(position.break_even()))
    });

    group.bench_function("pnl_at_expiration", |bencher| {
        bencher.iter(|| black_box(position.pnl_at_expiration(&Some(&test_price))))
    });

    group.bench_function("unrealized_pnl", |bencher| {
        bencher.iter(|| black_box(position.unrealized_pnl(test_price)))
    });

    group.bench_function("calculate_pnl", |bencher| {
        bencher.iter(|| {
            black_box(position.calculate_pnl(
                &test_price,
                ExpirationDate::Days(pos_or_panic!(15.0)),
                &pos_or_panic!(0.25),
            ))
        })
    });

    group.finish();
}

pub(crate) fn benchmark_time_calculations(c: &mut Criterion) {
    let mut group = c.benchmark_group("Time Calculations");
    let position = create_test_position();

    group.bench_function("days_held", |bencher| {
        bencher.iter(|| black_box(position.days_held()))
    });

    group.bench_function("days_to_expiration", |bencher| {
        bencher.iter(|| black_box(position.days_to_expiration()))
    });

    group.finish();
}

pub(crate) fn benchmark_validations(c: &mut Criterion) {
    let mut group = c.benchmark_group("Validation Operations");
    let position = create_test_position();

    group.bench_function("validate", |bencher| {
        bencher.iter(|| black_box(position.validate()))
    });

    group.bench_function("is_long", |bencher| {
        bencher.iter(|| black_box(position.is_long()))
    });

    group.bench_function("is_short", |bencher| {
        bencher.iter(|| black_box(position.is_short()))
    });

    group.finish();
}

criterion_group!(
    benches,
    benchmark_costs_and_fees,
    benchmark_profit_calculations,
    benchmark_time_calculations,
    benchmark_validations
);
criterion_main!(benches);