OptionStratLib v0.17.3: Financial Options Library

Table of Contents

• Introduction
• Features
• Core Modules
• Trading Strategies
• Setup Instructions
• Library Usage
• Usage Examples
• Testing
• Contribution and Contact

Introduction

OptionStratLib is a comprehensive Rust library for options trading and strategy development across multiple asset classes. This versatile toolkit enables traders, quants, and developers to model, analyze, and visualize options strategies with a robust, type-safe approach. The library focuses on precision with decimal-based calculations, extensive test coverage, and a modular architecture built on modern Rust 2024 edition.

Features

1. Pricing Models

• Black-Scholes Model: European options pricing with full Greeks support
• Binomial Tree Model: American and European options with early exercise capability
• Monte Carlo Simulations: Complex pricing scenarios and path-dependent options
• Telegraph Process Model: Advanced stochastic modeling for jump-diffusion processes
• American Options: Barone-Adesi-Whaley approximation for early exercise
• Exotic Options: Complete support for 14 exotic option types (see below)

2. Greeks Calculation

• Complete Greeks suite: Delta, Gamma, Theta, Vega, Rho, Vanna, Vomma, Veta,

Charm, Color

• Real-time sensitivity analysis
• Greeks visualization and risk profiling
• Custom Greeks implementations with adjustable parameters

3. Volatility Models

• Implied volatility calculation using Newton-Raphson method
• Volatility surface construction and interpolation
• Historical volatility estimation
• Advanced volatility modeling tools

4. Option Chain Management

• Complete option chain construction and analysis
• Strike price generation algorithms
• Chain data import/export (CSV/JSON formats)
• Advanced filtering and selection tools
• Option data grouping and organization

5. Trading Strategies (25+ Strategies)

• Single Leg: Long/Short Calls and Puts
• Spreads: Bull/Bear Call/Put Spreads
• Butterflies: Long/Short Butterfly Spreads, Call Butterfly
• Complex: Iron Condor, Iron Butterfly
• Volatility: Long/Short Straddles and Strangles
• Income: Covered Calls (with spot leg support), Poor Man's Covered Call
• Protection: Protective Puts, Collars
• Custom: Flexible custom strategy framework
• Multi-Asset: Strategies combining options with spot, futures, or perpetuals

6. Risk Management & Analysis

• Position tracking and management
• Break-even analysis with multiple break-even points
• Profit/Loss calculations at various price points
• Risk profiles and comprehensive visualizations
• Delta neutrality analysis and adjustment
• Probability analysis for strategy outcomes

7. Backtesting Framework

• Comprehensive backtesting engine
• Performance metrics calculation
• Strategy optimization tools
• Historical analysis capabilities

8. Simulation Tools

• Monte Carlo simulations for strategy testing
• Telegraph process implementation
• Random walk simulations
• Custom simulation frameworks
• Parametrized simulations with adjustable inputs

9. Visualization & Plotting

• Strategy payoff diagrams
• Greeks visualization
• 3D volatility surfaces
• Risk profiles and P&L charts
• Interactive charts (powered by plotly.rs)
• Binomial tree visualization
• Comprehensive plotting utilities

10. Data Management

• Efficient decimal-based calculations using rust_decimal
• CSV/JSON import/export functionality
• Time series data handling
• Price series management and manipulation
• Robust data validation and error handling

11. Mathematical Tools

• Curve interpolation techniques
• Surface construction and analysis
• Geometric operations for financial modeling
• Advanced mathematical utilities for options pricing

12. Exotic Option Pricing

Complete pricing support for all exotic option types:

• Asian: Arithmetic and geometric average price options
• Barrier: Up/Down, In/Out barrier options with rebates
• Binary: Cash-or-nothing and asset-or-nothing options
• Lookback: Fixed and floating strike lookback options
• Compound: Options on options
• Chooser: Options to choose call or put at future date
• Cliquet: Forward-starting options with local caps/floors
• Rainbow: Multi-asset best-of/worst-of options
• Spread: Kirk's approximation for price differentials
• Quanto: Currency-protected options
• Exchange: Margrabe's formula for asset exchange
• Power: Non-linear payoff options

Quality & Discipline (0.16.x)

The 0.16 line is a quality-hardening release. Every change below is enforced crate-wide and documented in CHANGELOG.md:

• Checked Decimal arithmetic. Every monetary-path kernel routes

through dadd / dsub / dmul / ddiv / d_sum / dsumiter in model::decimal. Overflow on any monetary expression surfaces DecimalError::Overflow { operation, lhs, rhs } tagged with a static call-site string; no silent wraparound.

• Non-finite f64 guards. Every f64 → Decimal boundary inside

pricing, Greeks, volatility, and simulation is wrapped with finite_decimal(..) and surfaces a domain-specific NonFinite { context, value } variant (PricingError, GreeksError, VolatilityError, SimulationError) instead of collapsing silently to Decimal::ZERO.

• NonZeroUsize step counts. price_binomial,

montecarlooption_pricing, telegraph and related kernels take std::num::NonZeroUsize for steps / simulations; zero is structurally invalid at the type level. Use the nz!(N) macro at literal call sites.

• Positive at every public boundary. Monetary values,

strikes, quantities, volatilities are Positive (newtype around Decimal). Strategy-level P&L goes through Positive::new_decimal(..) at every point where a signed Decimal would otherwise be clamped to Positive, so inverted strikes or out-of-range optimizer candidates return typed StrategyError rather than panicking.

• Zero unchecked indexing in production code.

#![deny(clippy::indexing_slicing)] is enforced crate-wide with scoped, documented escapes per module. Tests stay permissive via #![cfg_attr(test, allow(..))]. Production paths use .get(..).okorelse(..) with typed errors.

• Doc coverage floor. #![deny(missing_docs,

rustdoc::brokenintradoc_links)]. Every pub item has a /// summary; every Result returner documents its # Errors contract.

• Structured tracing. #[tracing::instrument] on the public

hot paths: pricing::black_scholes, pricing::montecarlooption_pricing, pricing::pricebinomial, volatility::impliedvolatility, and the strategy optimizer entry points getbestratio / getbestarea. No println! / eprintln! / dbg! / log:: anywhere in src/.

• Compiler-attribute discipline. #[must_use] on every pure

function and builder, #[inline] on small hot-path helpers, #[cold] #[inline(never)] on every error constructor, #[repr(u8)] on small stable enums, canonical #[derive] ordering.

• Deterministic simulation tests. utils::deterministic_rng(seed)

provides a canonical seeded StdRng for Monte-Carlo / simulation tests, so precision shifts in upstream arithmetic cannot flip assertions by luck.

• Pricing-identity regression tests. tests/unit/pricing/identities_test.rs

locks put-call parity on a grid, CRR binomial convergence to Black-Scholes, and the Greek sanity identities (Γc = Γp, Vegac = Vegap, Δc − Δp ≈ e^{-qT}).

Arithmetic-Error Cascade

flowchart LR
    subgraph Kernels["Numeric kernels (model / pricing / greeks / volatility / simulation)"]
        DADD["dadd / dsub / dmul / ddiv"]
        DSUM["dsum / dsum_iter"]
        FD["finite_decimal(f64)"]
    end
subgraph Errors["Typed errors (error/*)"]         DOV["DecimalError::Overflow { operation, lhs, rhs }"]         PNF["PricingError::NonFinite { context, value }"]         GNF["GreeksError::NonFinite"]         VNF["VolatilityError::NonFinite"]         SNF["SimulationError::NonFinite"]     end
DADD -- "checked_*" --> DOV     DSUM -- "checked_*" --> DOV     FD -- "NaN / ±∞ guard" --> PNF     FD --> GNF     FD --> VNF     FD --> SNF
DOV -- "#[from]" --> PNF     DOV -- "#[from]" --> GNF     DOV -- "#[from]" --> VNF     DOV -- "#[from]" --> SNF

Core Modules

The library is organized into the following key modules:

Model (model/)

Core data structures and types for options trading:

• option.rs: Complete option structures with pricing and Greeks
• position.rs: Position management and P&L tracking
• expiration.rs: Flexible expiration date handling (Days/DateTime)
• positive.rs: Type-safe positive number implementation
• types.rs: Common enums (OptionType, Side, OptionStyle)
• trade.rs: Trade execution and management
• format.rs: Data formatting utilities
• leg/: Multi-instrument leg support for strategies

- traits.rs: Common leg traits (LegAble, Marginable, Fundable, Expirable) - spot.rs: SpotPosition for underlying asset positions - perpetual.rs: PerpetualPosition for crypto perpetual swaps - future.rs: FuturePosition for exchange-traded futures - leg_enum.rs: Leg enum unifying all position types

Pricing Models (pricing/)

Advanced pricing engines for options valuation:

• blackscholesmodel.rs: European options pricing with Greeks
• black_76.rs: European options on futures/forwards (Black 1976)
• garman_kohlhagen.rs: European FX options (Garman-Kohlhagen 1983)
• binomial_model.rs: American/European options with early exercise
• monte_carlo.rs: Path-dependent and exotic options pricing
• telegraph.rs: Jump-diffusion process modeling
• payoff.rs: Payoff function implementations
• american.rs: Barone-Adesi-Whaley approximation
• Exotic Options:

- asian.rs: Asian option pricing - barrier.rs: Barrier option pricing - binary.rs: Binary/Digital option pricing - lookback.rs: Lookback option pricing - compound.rs: Compound option pricing - chooser.rs: Chooser option pricing - cliquet.rs: Cliquet option pricing - rainbow.rs: Rainbow option pricing - spread.rs: Spread option pricing - quanto.rs: Quanto option pricing - exchange.rs: Exchange option pricing - power.rs: Power option pricing

Strategies (strategies/)

Comprehensive trading strategy implementations:

• base.rs: Core traits (Strategable, BasicAble, Positionable, etc.)
• Single Leg: longcall.rs, shortcall.rs, longput.rs, shortput.rs
• Spreads: bullcallspread.rs, bearcallspread.rs, bullputspread.rs, bearputspread.rs
• Butterflies: longbutterflyspread.rs, shortbutterflyspread.rs, call_butterfly.rs
• Complex: ironcondor.rs, ironbutterfly.rs
• Volatility: longstraddle.rs, shortstraddle.rs, longstrangle.rs, shortstrangle.rs
• Income: coveredcall.rs, poormanscoveredcall.rs
• Protection: protective_put.rs, collar.rs
• custom.rs: Flexible custom strategy framework
• probabilities/: Probability analysis for strategy outcomes
• delta_neutral/: Delta neutrality analysis and adjustment

Volatility (volatility/)

Volatility modeling and analysis:

• utils.rs: Implied volatility calculation (Newton-Raphson method)
• traits.rs: Volatility model interfaces
• Advanced volatility surface construction

Greeks (greeks/)

Complete Greeks calculation suite:

• Delta, Gamma, Theta, Vega, Rho, Vanna, Vomma, Veta, Charm, Color calculations
• Real-time sensitivity analysis
• Greeks-based risk management

Chains (chains/)

Option chain management and analysis:

• chain.rs: Option chain construction and manipulation
• utils.rs: Chain analysis and filtering tools
• CSV/JSON import/export functionality
• Strike price generation algorithms

Backtesting (backtesting/)

Strategy performance analysis:

• metrics.rs: Performance metrics calculation
• results.rs: Backtesting results management
• types.rs: Backtesting data structures

Simulation (simulation/)

Monte Carlo and stochastic simulations:

• Random walk implementations
• Telegraph process modeling
• Custom simulation frameworks
• Parametrized simulation tools

Visualization (visualization/)

Comprehensive plotting and charting:

• plotly.rs: Interactive charts with Plotly integration
• Strategy payoff diagrams
• Greeks visualization
• 3D volatility surfaces
• Risk profile charts

Metrics (metrics/)

Performance, risk, and liquidity metrics analysis:

• Price Metrics: Volatility skew curves
• Risk Metrics:

- Implied Volatility curves (by strike) and surfaces (strike vs time) - Risk Reversal curves (by strike) - Dollar Gamma curves (by strike)

• Composite Metrics:

- Vanna-Volga Hedge surfaces (price vs volatility) - Delta-Gamma Profile curves (by strike) and surfaces (price vs time) - Smile Dynamics curves (by strike) and surfaces (strike vs time)

• Liquidity Metrics:

- Bid-Ask Spread curves (by strike) - Volume Profile curves (by strike) and surfaces (strike vs time) - Open Interest Distribution curves (by strike)

• Stress Metrics:

- Volatility Sensitivity curves (by strike) and surfaces (price vs volatility) - Time Decay Profile curves (by strike) and surfaces (price vs time) - Price Shock Impact curves (by strike) and surfaces (price vs volatility)

• Temporal Metrics:

- Theta curves (by strike) and surfaces (price vs time) - Charm (Delta Decay) curves (by strike) and surfaces (price vs time) - Color (Gamma Decay) curves (by strike) and surfaces (price vs time)

Risk Management (risk/)

Risk analysis and management tools:

• Position risk metrics
• Break-even analysis
• Risk profile generation

P&L (pnl/)

Profit and loss calculation:

• Real-time P&L tracking
• Historical P&L analysis
• Performance attribution

Curves & Surfaces (curves/, surfaces/)

Mathematical tools for financial modeling:

• Curve interpolation techniques
• Surface construction and analysis
• 3D visualization capabilities

Error Handling (error/)

Robust error management:

• Comprehensive error types for each module
• Type-safe error propagation
• Detailed error reporting

Core Components

classDiagram
class Options {
+option_type: OptionType
+side: Side
+underlying_symbol: String
+strike_price: Positive
+expiration_date: ExpirationDate
+implied_volatility: Positive
+quantity: Positive
+underlying_price: Positive
+riskfreerate: Decimal
+option_style: OptionStyle
+dividend_yield: Positive
+exotic_params: Option~ExoticParams~
+calculatepriceblack_scholes()
+calculatepricebinomial()
+timetoexpiration()
+is_long()
+is_short()
+validate()
+to_plot()
+calculateimpliedvolatility()
+delta()
+gamma()
+theta()
+vega()
+rho()
+vanna()
+vomma()
+veta()
+charm()
+color()
}
class Position { +option: Options +position_cost: Positive +entry_date: DateTime<Utc> +open_fee: Positive +close_fee: Positive +net_cost() +netpremiumreceived() +unrealized_pnl() +pnlatexpiration() +validate() }
class Leg { <<enumeration>> Option(Position) Spot(SpotPosition) Future(FuturePosition) Perpetual(PerpetualPosition) +is_option() +is_spot() +is_linear() +delta() +pnlatprice() }
class SpotPosition { +symbol: String +quantity: Positive +cost_basis: Positive +side: Side +date: DateTime<Utc> +open_fee: Positive +close_fee: Positive +pnlatprice() +delta() +market_value() +breakevenprice() }
class ExpirationDate { +Days(Positive) +Date(NaiveDate) +get_years() +get_date() +getdatestring() +from_string() }
class Positive { +value: Decimal +ZERO: Positive +ONE: Positive +formatfixedplaces() +roundtonice_number() +is_positive() }
class OptionStyle { <<enumeration>> Call Put }
class OptionType { <<enumeration>> European American Bermuda Asian Barrier Binary Lookback Compound Chooser Cliquet Rainbow Spread Quanto Exchange Power }
class Side { <<enumeration>> Long Short }
class Graph { <<interface>> +graph_data() +graph_config() +to_plot() +write_html() +write_png() +write_svg() +write_jpeg() }
class Greeks { <<interface>> +delta() +gamma() +theta() +vega() +rho() +calculateallgreeks() }
Options --|> Greeks : implements Options --|> Graph : implements Position o-- Options : contains Leg o-- Position : Option variant Leg o-- SpotPosition : Spot variant SpotPosition *-- Side : has SpotPosition *-- Positive : uses Options *-- OptionStyle : has Options *-- OptionType : has Options *-- Side : has Options *-- ExpirationDate : has Options *-- Positive : uses

Pricing Models Architecture

flowchart TB
    subgraph Standard["Standard Options"]
        EU[European]
        AM[American]
        BE[Bermuda]
    end
subgraph PathDependent["Path-Dependent"]         AS[Asian]         LB[Lookback]         BA[Barrier]         CL[Cliquet]     end
subgraph MultiAsset["Multi-Asset"]         RB[Rainbow]         SP[Spread]         EX[Exchange]     end
subgraph Special["Special Payoffs"]         BI[Binary]         PW[Power]         QU[Quanto]         CO[Compound]         CH[Chooser]     end
subgraph Forward["Forward-Priced"]         FUT[Future]         FWD[Forward]     end
subgraph FX["FX / Currency"]         FX_S[FX Spot]     end
BS[black_scholes] --> EU     BS --> PathDependent     BS --> MultiAsset     BS --> Special     B76[black_76] --> Forward     GK[garman_kohlhagen] --> FX     BAW[baroneadesiwhaley] --> AM     BIN[binomial_model] --> AM     BIN --> BE     MC[monte_carlo] --> PathDependent

Strategy Traits System

classDiagram
    class Strategable {
        <<trait>>
        Master trait combining all capabilities
    }
class BasicAble {         <<trait>>         +getunderlyingprice()         +getunderlyingsymbol()         +get_expiration()         +get_title()     }
class Positionable {         <<trait>>         +get_positions()         +add_position()         +modify_position()     }
class Strategies {         <<trait>>         +getnetpremium_received()         +getmaxprofit()         +getmaxloss()         +gettotalcost()     }
class BreakEvenable {         <<trait>>         +getbreakeven_points()         +calculatebreakeven()     }
class Profit {         <<trait>>         +getpointat_price()         +calculateprofitat()     }
class Greeks {         <<trait>>         +delta()         +gamma()         +theta()         +vega()     }
class DeltaNeutrality {         <<trait>>         +get_delta()         +suggestdeltaadjustments()     }
class Graph {         <<trait>>         +to_plot()         +write_html()         +write_png()     }
Strategable --|> BasicAble     Strategable --|> Positionable     Strategable --|> Strategies     Strategable --|> BreakEvenable     Strategable --|> Profit     Strategable --|> Greeks     Strategable --|> DeltaNeutrality     Strategable --|> Graph

Metrics Framework

flowchart LR
    subgraph OptionChain
        OC[OptionChain]
    end
subgraph Curves["Curve Metrics"]         IV_C[IV Curve]         RR_C[Risk Reversal]         DG_C[Dollar Gamma]         TH_C[Theta Curve]         VA_C[Vanna Curve]         SK_C[Skew Curve]     end
subgraph Surfaces["Surface Metrics"]         IV_S[IV Surface]         TH_S[Theta Surface]         CH_S[Charm Surface]         VS_S[Vol Sensitivity]         TD_S[Time Decay]     end
OC --> Curves     OC --> Surfaces     Curves --> |"2D Analysis"| Analysis[Risk Analysis]     Surfaces --> |"3D Analysis"| Analysis

Observability

Public hot paths are annotated with #[tracing::instrument]. Enable a subscriber in the consumer crate (the library itself never installs one) to surface structured spans:

flowchart LR
    APP[Consumer application] -- "installs" --> SUB["tracing_subscriber"]
subgraph Spans["Instrumented public fns"]         BS["pricing::black_scholes\n(strike, style, side)"]         MC["pricing::montecarlooption_pricing\n(steps, simulations, strike, style, side)"]         BI["pricing::price_binomial\n(strike, asset, steps, style, side)"]         IV["volatility::impliedvolatility\n(marketprice, strike, max_iterations)"]         OPT["Optimizable::getbestratio/area\n(side, criteria)"]     end
BS --> SUB     MC --> SUB     BI --> SUB     IV --> SUB     OPT --> SUB

Trading Strategies

OptionStratLib provides 25+ comprehensive trading strategies organized by complexity and market outlook:

Single Leg Strategies

Basic directional strategies for beginners:

• Long Call: Bullish strategy with unlimited upside potential
• Short Call: Bearish strategy collecting premium with limited profit
• Long Put: Bearish strategy with high profit potential
• Short Put: Bullish strategy collecting premium with assignment risk

Spread Strategies

Defined risk strategies with limited profit/loss:

• Bull Call Spread: Moderately bullish with limited risk and reward
• Bear Call Spread: Moderately bearish credit spread
• Bull Put Spread: Moderately bullish credit spread
• Bear Put Spread: Moderately bearish debit spread

Butterfly Strategies

Market neutral strategies profiting from low volatility:

• Long Butterfly Spread: Profits from price staying near middle strike
• Short Butterfly Spread: Profits from price moving away from middle strike
• Call Butterfly: Butterfly using only call options

Complex Multi-Leg Strategies

Advanced strategies for experienced traders:

• Iron Condor: Market neutral strategy with wide profit zone
• Iron Butterfly: Market neutral strategy with narrow profit zone

Volatility Strategies

Strategies that profit from volatility changes:

• Long Straddle: Profits from high volatility in either direction
• Short Straddle: Profits from low volatility (range-bound market)
• Long Strangle: Similar to straddle but with different strikes
• Short Strangle: Credit strategy profiting from low volatility

Income Generation Strategies

Strategies focused on generating regular income:

• Covered Call: Stock/spot ownership with call selling for income (now with full spot leg support)
• Poor Man's Covered Call: LEAPS-based covered call alternative

Protection Strategies

Risk management and hedging strategies:

• Protective Put: Downside protection for stock positions
• Collar: Combination of covered call and protective put

Custom Strategy Framework

• Custom Strategy: Flexible framework for creating any multi-leg strategy
• Supports unlimited number of legs
• Full integration with all analysis tools
• Complete trait implementation for consistency

Strategy Analysis Features

All strategies include comprehensive analysis capabilities:

• Profit/Loss Analysis: P&L at any price point and time
• Break-Even Points: Multiple break-even calculations
• Greeks Analysis: Real-time risk metrics
• Probability Analysis: Success probability calculations
• Delta Neutrality: Delta-neutral position analysis
• Visualization: Interactive payoff diagrams and risk profiles
• Optimization: Find optimal strikes and expirations

Strategy Traits System

All strategies implement a comprehensive trait system:

• Strategable: Master trait combining all strategy capabilities
• BasicAble: Basic strategy information (symbol, price, etc.)
• Positionable: Position management and modification
• Strategies: Core strategy calculations (P&L, break-even, etc.)
• Validable: Strategy validation and error checking
• BreakEvenable: Break-even point calculations
• Profit: Profit/loss analysis at various price points
• Greeks: Greeks calculations for risk management
• DeltaNeutrality: Delta-neutral analysis and adjustments
• ProbabilityAnalysis: Outcome probability calculations
• Graph: Visualization and plotting capabilities

Setup Instructions

Prerequisites

• Rust 1.85 or higher (Rust 2024 edition)
• Cargo package manager

Installation

Add OptionStratLib to your Cargo.toml:

[dependencies]
optionstratlib = "0.17.3"

Or use cargo to add it to your project:

cargo add optionstratlib

Optional Features

The library includes optional features for enhanced functionality:

[dependencies]
optionstratlib = { version = "0.17.3", features = ["plotly"] }

• plotly: Enables interactive visualization using plotly.rs
• staticexport: PNG / SVG export via plotlystatic (pulls in async runtime)
• async: Enables asynchronous I/O operations for OptionChain and OHLCV data (tokio + reqwest + futures)

Building from Source

Clone the repository and build using Cargo:

git clone https://github.com/joaquinbejar/OptionStratLib.git
cd OptionStratLib
cargo build --release

Run comprehensive test suite:

cargo test --all-features

Generate documentation:

cargo doc --open --all-features

Run benchmarks:

cargo bench

Library Usage

Basic Option Creation and Pricing

use optionstratlib::{Options, OptionStyle, OptionType, Side, ExpirationDate};
use positive::{posorpanic,Positive};
use rustdecimalmacros::dec;
use optionstratlib::greeks::Greeks;
fn main() -> Result<(), optionstratlib::error::Error> {     // Create a European call option     let option = Options::new(         OptionType::European,         Side::Long,         "AAPL".to_string(),         posorpanic!(150.0),            // strike_price         ExpirationDate::Days(posorpanic!(30.0)),         posorpanic!(0.25),             // implied_volatility         Positive::ONE,              // quantity         posorpanic!(155.0),            // underlying_price         dec!(0.05),             // riskfreerate         OptionStyle::Call,         posorpanic!(0.02),             // dividend_yield         None,                   // exotic_params     );
// Calculate option price using Black-Scholes     let price = option.calculatepriceblack_scholes()?;     tracing::info!("Option price: ${:.2}", price);
// Calculate Greeks for risk management     let delta = option.delta()?;     let gamma = option.gamma()?;     let theta = option.theta()?;     let vega = option.vega()?;     let vanna = option.vanna()?;     let vomma = option.vomma()?;     let veta = option.veta()?;     let charm = option.charm()?;     let color = option.color()?;     tracing::info!("Greeks - Delta: {:.4}, Gamma: {:.4}, Theta: {:.4},         Vega: {:.4}, Vanna: {:.4}, Vomma: {:.4}, Veta: {:.4}         Charm: {:.4}, Color: {:.4}",         delta, gamma, theta, vega, vanna, vomma, veta, charm, color);     Ok(()) }

Working with Trading Strategies

use positive::{Positive, posorpanic};
use optionstratlib::ExpirationDate;
use optionstratlib::strategies::Strategies;
use optionstratlib::strategies::bullcallspread::BullCallSpread;
use optionstratlib::strategies::base::{BreakEvenable, BasicAble};
use optionstratlib::visualization::Graph;
use rustdecimalmacros::dec;
use std::error::Error;
fn main() -> Result<(), optionstratlib::error::Error> {     use optionstratlib::pricing::Profit; let underlying_price = Positive::HUNDRED;
// Create a Bull Call Spread strategy     let strategy = BullCallSpread::new(         "AAPL".to_string(),         underlying_price,         posorpanic!(95.0),   // long_strike         posorpanic!(105.0),  // short_strike         ExpirationDate::Days(posorpanic!(30.0)),         posorpanic!(0.25),   // implied_volatility         dec!(0.05),   // riskfreerate         posorpanic!(2.50),   // longcallpremium         posorpanic!(2.50),   // longcallopen_fee         posorpanic!(1.20),   // shortcallpremium         posorpanic!(1.20),   // shortcallclose_fee         Default::default(), Default::default(),         Default::default(), Default::default()     )?;
// Analyze the strategy     tracing::info!("Strategy: {}", strategy.get_title());     tracing::info!("Break-even points: {:?}", strategy.getbreakeven_points()?);     tracing::info!("Max profit: ${:.2}", strategy.getmaxprofit().unwrap_or(Positive::ZERO));     tracing::info!("Max loss: ${:.2}", strategy.getmaxloss().unwrap_or(Positive::ZERO));     tracing::info!("Net premium: ${:.2}", strategy.getnetpremium_received()?);
// Calculate P&L at different price points     let prices = vec![posorpanic!(90.0), posorpanic!(95.0), Positive::HUNDRED, posorpanic!(105.0), posorpanic!(110.0)];     for price in prices {         let pnl = strategy.getpointat_price(&price)?;         tracing::info!("P&L at ${}: ${:.2}", price, pnl.0);     }
// Generate visualization     #[cfg(feature = "plotly")]     {         strategy.writehtml("Draws/Visualization/bullcallspread.html".asref())?;     }
Ok(()) }

Advanced Features: Volatility Analysis

use optionstratlib::prelude::*;
fn main() -> Result<(), optionstratlib::error::Error> {     // Create an option for implied volatility calculation     let mut option = Options::new(         OptionType::European,         Side::Long,         "AAPL".to_string(),         posorpanic!(105.0), // strike         ExpirationDate::Days(posorpanic!(90.0)),         posorpanic!(0.20), // initial IV guess         Positive::ONE, // quantity         Positive::HUNDRED, // underlying price         dec!(0.05), // risk free rate         OptionStyle::Call,         posorpanic!(0.02), // dividend yield         None,     );
let marketprice = posor_panic!(5.50);     let iv = impliedvolatility(marketprice, &mut option, 100)?;
tracing::info!("Implied volatility: {:.2}%", iv.to_f64() * 100.0);     Ok(()) }

Custom Strategy Creation

use optionstratlib::prelude::*;
fn main() -> Result<(), optionstratlib::error::Error> {     // Define common parameters     let underlyingsymbol = "DAX".tostring();     let underlyingprice = posor_panic!(24000.0);     let expiration = ExpirationDate::Days(posorpanic!(30.0));     let impliedvolatility = posor_panic!(0.25);     let riskfreerate = dec!(0.05);     let dividendyield = posor_panic!(0.02);     let fee = Positive::TWO;
// Create a long put option     let longputoption = Options::new(         OptionType::European,         Side::Long,         underlying_symbol.clone(),         posorpanic!(24070.0), // strike         expiration.clone(),         implied_volatility,         Positive::ONE, // quantity         underlying_price,         riskfreerate,         OptionStyle::Put,         dividend_yield,         None,     );     let long_put = Position::new(         longputoption,         posorpanic!(150.0), // premium         Utc::now(),         fee,         fee,         None,         None,     );
// Create a long call option     let longcalloption = Options::new(         OptionType::European,         Side::Long,         underlying_symbol.clone(),         posorpanic!(24030.0), // strike         expiration.clone(),         implied_volatility,         Positive::ONE, // quantity         underlying_price,         riskfreerate,         OptionStyle::Call,         dividend_yield,         None,     );     let long_call = Position::new(         longcalloption,         posorpanic!(120.0), // premium         Utc::now(),         fee,         fee,         None,         None,     );
// Create CustomStrategy with the positions     let positions = vec![longcall, longput];     let strategy = CustomStrategy::new(         "DAX Straddle Strategy".to_string(),         underlying_symbol,         "A DAX long straddle strategy".to_string(),         underlying_price,         positions,         Positive::ONE,         30,         implied_volatility,     )?;
tracing::info!("Strategy created: {}", strategy.get_title());     Ok(()) }

Testing

OptionStratLib ships with a large, fully deterministic test suite (3760 unit / integration tests + 205 doctests + property- and identity-based regressions):

Running Tests

Run all tests:

cargo test --all-features

Run tests for specific modules:

cargo test strategies::bullcallspread cargo test pricing::black_scholes cargo test volatility::utils

Run tests with output:

cargo test -- --nocapture

Test Categories

• Unit Tests: Individual function and method testing
• Integration Tests: Cross-module functionality under tests/
• Strategy Tests: Comprehensive strategy validation
• Pricing Model Tests: Accuracy and performance testing
• Greeks Tests: Mathematical precision validation
• Visualization Tests: Chart generation and export testing
• Property-Based Tests: Mathematical invariant testing with proptest

(tests/property/putcallparitytest.rs, greeksbounds_test.rs)

• Identity Regression Tests: tests/unit/pricing/identities_test.rs

locks put-call parity, CRR → Black-Scholes convergence, and Greek sanity (Γc = Γp, Vegac = Vegap, Δc − Δp ≈ e^{-qT}).

• Deterministic Monte-Carlo Tests: Seeded via

[utils::deterministic_rng] so arithmetic-precision shifts can't flip assertions.

• Exotic Options Tests: Complete coverage for all 14 exotic

option types.

Benchmarking

Run performance benchmarks:

cargo bench

Generate test coverage report:

cargo tarpaulin --all-features --out Html

Examples

Examples live in self-contained sub-crates under examples/, each with its own Cargo.toml:

• examples_strategies/: 25+ strategy demos
• examplesstrategiesbest/: Optimizer entry points

(getbestarea / getbestratio) per strategy

• examplesstrategiesdelta/: Delta-neutrality workflows
• examples_chain/: Option chain construction, import/export,

and async I/O

• examples_curves/: Greek curves (charm, color, d1, d2,

delta, gamma, rho, theta, …) and vector curves

• examples_surfaces/: 3-D volatility surfaces
• examples_metrics/: Price / risk / liquidity / stress /

temporal / composite metric curves and surfaces

• examples_volatility/: Implied-volatility solver walkthroughs
• examples_simulation/: Monte-Carlo random-walk demos for

LongCall, ShortPut, position / strategy simulators, and random-walk-of-chain

• examples_exotics/: Exotic option pricing (barrier,

cliquet, …)

• examples_visualization/: Interactive chart wiring

Run any binary with the usual cargo invocation (from the repo root, so relative data-fixture paths resolve correctly):

cargo run --manifest-path=examples/examples_strategies/Cargo.toml \
    --bin strategybullcall_spread
cargo run --manifest-path=examples/examples_simulation/Cargo.toml \
    --bin longcallstrategy_simulation --features plotly
cargo run --manifest-path=examples/examples_metrics/Cargo.toml \
    --bin impliedvolatilitysurface

Simulation-heavy demos (*strategysimulation, position_simulator, strategysimulator, randomwalk_chain) use a demo-friendly hourly grid so cargo run finishes in a few seconds in debug mode; bump nsteps / nsimulations inside the binary if you want a finer sample.

Contribution and Contact

Contributing

Contributions are welcome! Please follow these guidelines:

• Fork the repository
• Create a feature branch: git checkout -b feature/amazing-feature
• Commit your changes: git commit -m 'Add amazing feature'
• Push to the branch: git push origin feature/amazing-feature
• Open a Pull Request

Development Setup

git clone https://github.com/joaquinbejar/OptionStratLib.git
cd OptionStratLib
cargo build --all-features
cargo test --all-features

Code Quality

• All code must pass cargo clippy without warnings
• Format code with cargo fmt
• Add tests for new functionality
• Update documentation for API changes
• Follow Rust 2024 edition best practices

Support

• Issues: Report bugs and request features on GitHub
• Discussions: Join community discussions on GitHub Discussions
• Documentation: Comprehensive docs available at docs.rs

---

OptionStratLib v0.17.3 - Built with ❤️ in Rust for the financial community

Contribution and Contact

We welcome contributions to this project! If you would like to contribute, please follow these steps:

• Fork the repository.
• Create a new branch for your feature or bug fix.
• Make your changes and ensure that the project still builds and all tests pass.
• Commit your changes and push your branch to your forked repository.
• Submit a pull request to the main repository.

If you have any questions, issues, or would like to provide feedback, please feel free to contact the project maintainer:

Contact Information

• Author: Joaquín Béjar García
• Email: jb@taunais.com
• Telegram: @joaquin_bejar
• Repository:
• Documentation:

We appreciate your interest and look forward to your contributions!

✍️ License

Licensed under MIT license