Examples by Subject

1. Event-Driven Data and Labeling

use chrono::NaiveDateTime;
use openquant::filters::{cusum_filter_timestamps, Threshold};
use openquant::labeling::{add_vertical_barrier, get_bins, get_events};
use openquant::util::volatility::get_daily_vol;

let close: Vec<(NaiveDateTime, f64)> = /* timestamped close series */;
let prices: Vec<f64> = close.iter().map(|(_, p)| *p).collect();
let timestamps: Vec<NaiveDateTime> = close.iter().map(|(ts, _)| *ts).collect();

let events = cusum_filter_timestamps(&prices, ×tamps, Threshold::Scalar(0.02));
let target = get_daily_vol(&close, 100);
let barriers = add_vertical_barrier(&events, &close, 1, 0, 0, 0);

let labeled_events = get_events(
    &close,
    &events,
    (1.0, 1.0),
    &target,
    0.005,
    3,
    Some(&barriers),
    None,
);
let labels = get_bins(&labeled_events, &close);

2. Sampling, Validation and ML Diagnostics

use openquant::sampling::seq_bootstrap;
use openquant::cross_validation::{ml_cross_val_score, PurgedKFold, Scoring};

let ind_mat = vec![vec![1, 0, 1], vec![0, 1, 1], vec![1, 1, 0]];
let boot = seq_bootstrap(&ind_mat, Some(3), None);

// Use PurgedKFold and ml_cross_val_score with your classifier implementation.
let _ = (boot, Scoring::NegLogLoss);

3. Position Sizing and Trade Construction

use openquant::bet_sizing::bet_size_probability;
use chrono::NaiveDateTime;

let ts0 = NaiveDateTime::parse_from_str("2024-01-01 09:30:00", "%Y-%m-%d %H:%M:%S")?;
let ts1 = NaiveDateTime::parse_from_str("2024-01-01 16:00:00", "%Y-%m-%d %H:%M:%S")?;
let events = vec![
    (ts0, ts1, 0.55, 1.0),
    (ts0, ts1, 0.62, 1.0),
    (ts0, ts1, 0.48, -1.0),
];
let size = bet_size_probability(
    &events,
    2,
    0.1,
    false,
);

4. Portfolio Construction and Risk

use nalgebra::DMatrix;
use openquant::portfolio_optimization::{
    allocate_max_sharpe, allocate_min_vol, AllocationOptions, ReturnsMethod
};

let prices: DMatrix<f64> = /* rows=time, cols=assets */;
let min_vol = allocate_min_vol(&prices, None, None)?;
let max_sharpe = allocate_max_sharpe(&prices, 0.0, None, None)?;

let opts = AllocationOptions {
    returns_method: ReturnsMethod::Exponential { span: 50 },
    ..Default::default()
};
let exp_weighted = openquant::portfolio_optimization::allocate_inverse_variance_with(&prices, &opts)?;

5. Market Microstructure, Dependence and Regime Detection

use openquant::risk_metrics::RiskMetrics;
use openquant::microstructural_features::get_roll_measure;
use openquant::structural_breaks::get_sadf;

let returns = vec![-0.015, 0.007, 0.011, -0.006, 0.004];
let var_95 = RiskMetrics::calculate_value_at_risk(&returns, 0.05)?;
let es_95 = RiskMetrics::calculate_expected_shortfall(&returns, 0.05)?;
let spread = get_roll_measure(&[100.0, 100.2, 100.1, 100.3], 2);
let _ = (es_95, var_95, spread);
// get_sadf(...) is typically run on longer time series with explicit lag config.

Example Design Principles

• Prefer deterministic fixture-backed experiments for comparisons.
• Separate exploratory notebooks from committed regression tests.
• Track benchmark and numerical tolerance drift explicitly in PRs.