rusty_strategy/

lib.rs

//! # Rusty Strategy
//!
//! This crate contains the core trading strategy logic for the Rusty Trading System.
//! It is responsible for analyzing market data, generating trading signals, and managing
//! the overall trading strategy.

/// Dual-mode feature calculation for both scalar and vectorized operations.
pub mod dual_mode_features;
/// The main trading strategy engine.
pub mod engine;
/// Calculates microstructure features from market data.
pub mod microstructure;
/// Generates trading signals based on market data and strategy logic.
pub mod signals;
/// Defines the core trading strategy trait and implementations.
pub mod strategy;
/// Utility functions for the strategy crate.
pub mod utils;
/// Vectorized feature calculation for high-performance analysis.
pub mod vectorized_features;

// Re-export key types for easier access
pub use microstructure::{MicrostructureCalculator, TradeFeatures};
pub use vectorized_features::{
    PriceFeatures, VectorizedFeatures, VolumeFeatures, WeightedFeatures,
};

#[cfg(test)]
mod simd_integration_tests {
    use super::*;
    use rust_decimal::Decimal;
    use rust_decimal_macros::dec;

    // Const decimal values for compile-time evaluation
    const ASK_QTY_100: Decimal = dec!(100.0);
    const ASK_QTY_150: Decimal = dec!(150.0);
    const ASK_QTY_200: Decimal = dec!(200.0);
    const ASK_QTY_250: Decimal = dec!(250.0);
    const ASK_QTY_300: Decimal = dec!(300.0);

    const BID_QTY_120: Decimal = dec!(120.0);
    const BID_QTY_180: Decimal = dec!(180.0);
    const BID_QTY_240: Decimal = dec!(240.0);
    const BID_QTY_300: Decimal = dec!(300.0);
    const BID_QTY_360: Decimal = dec!(360.0);

    // Price constants for ML features test
    const ASK_PRICE_50010: Decimal = dec!(50010.0);
    const ASK_PRICE_50020: Decimal = dec!(50020.0);
    const ASK_PRICE_50030: Decimal = dec!(50030.0);
    const ASK_PRICE_50040: Decimal = dec!(50040.0);
    const ASK_PRICE_50050: Decimal = dec!(50050.0);

    const BID_PRICE_49990: Decimal = dec!(49990.0);
    const BID_PRICE_49980: Decimal = dec!(49980.0);
    const BID_PRICE_49970: Decimal = dec!(49970.0);
    const BID_PRICE_49960: Decimal = dec!(49960.0);
    const BID_PRICE_49950: Decimal = dec!(49950.0);

    // Additional test constants
    const TRADE_QTY_50: Decimal = dec!(50.0);
    const TRADE_QTY_75: Decimal = dec!(75.0);
    const TRADE_QTY_60: Decimal = dec!(60.0);
    const TOLERANCE: Decimal = dec!(0.0001);

    #[test]
    fn test_simd_integration_basic() {
        let calc = MicrostructureCalculator::<128>::new(100);

        // Test data with sufficient size to trigger SIMD path
        let ask_qty = vec![
            ASK_QTY_100,
            ASK_QTY_150,
            ASK_QTY_200,
            ASK_QTY_250,
            ASK_QTY_300,
        ];

        let bid_qty = vec![
            BID_QTY_120,
            BID_QTY_180,
            BID_QTY_240,
            BID_QTY_300,
            BID_QTY_360,
        ];

        // Test SIMD-optimized order imbalance calculation
        let imbalance = calc.calc_order_imbalance(&ask_qty, &bid_qty);
        assert!(
            !imbalance.is_zero(),
            "SIMD order imbalance should return a non-zero value"
        );

        // Test SIMD-optimized queue imbalance calculation
        let queue_imbalance = calc.calc_queue_imbalance(&ask_qty, &bid_qty);
        assert!(
            !queue_imbalance.is_zero(),
            "SIMD queue imbalance should return a non-zero value"
        );

        // Test SIMD-optimized order book pressure calculation
        let pressure = calc.calc_order_book_pressure(&ask_qty, &bid_qty, 5);
        assert!(
            !pressure.is_zero(),
            "SIMD order book pressure should return a non-zero value"
        );

        println!("✅ SIMD integration test passed!");
        println!("Order imbalance: {imbalance}");
        println!("Queue imbalance: {queue_imbalance}");
        println!("Order book pressure: {pressure}");
    }

    #[test]
    fn test_simd_fallback_for_small_arrays() {
        let calc = MicrostructureCalculator::<128>::new(100);

        // Test data with small size to trigger scalar fallback
        let ask_qty = vec![ASK_QTY_100, ASK_QTY_150];

        let bid_qty = vec![BID_QTY_120, BID_QTY_180];

        // Should fallback to scalar implementation for small arrays
        let imbalance = calc.calc_order_imbalance(&ask_qty, &bid_qty);
        assert!(
            !imbalance.is_zero(),
            "Scalar fallback should work for small arrays"
        );

        println!("✅ SIMD fallback test passed!");
        println!("Small array imbalance: {imbalance}");
    }

    #[test]
    fn test_ml_features_simd_vs_scalar_correctness() {
        use microstructure::{OrderSide, TradeFeatures};

        let calc = MicrostructureCalculator::<128>::new(100);

        // Create comprehensive test data
        let ask_prices = vec![
            ASK_PRICE_50010,
            ASK_PRICE_50020,
            ASK_PRICE_50030,
            ASK_PRICE_50040,
            ASK_PRICE_50050,
        ];

        let bid_prices = vec![
            BID_PRICE_49990,
            BID_PRICE_49980,
            BID_PRICE_49970,
            BID_PRICE_49960,
            BID_PRICE_49950,
        ];

        let ask_volumes = vec![
            ASK_QTY_100,
            ASK_QTY_150,
            ASK_QTY_200,
            ASK_QTY_250,
            ASK_QTY_300,
        ];

        let bid_volumes = vec![
            BID_QTY_120,
            BID_QTY_180,
            BID_QTY_240,
            BID_QTY_300,
            BID_QTY_360,
        ];

        let trades = vec![
            TradeFeatures::new(ask_prices[0], TRADE_QTY_50, OrderSide::Buy),
            TradeFeatures::new(bid_prices[0], TRADE_QTY_75, OrderSide::Sell),
            TradeFeatures::new(ask_prices[1], TRADE_QTY_60, OrderSide::Buy),
        ];

        let window = 2;

        // Calculate using both methods
        let scalar_features = calc.calc_ml_features(
            &ask_prices,
            &ask_volumes,
            &bid_prices,
            &bid_volumes,
            &trades,
            window,
        );

        let simd_features = calc.calc_ml_features_simd(
            &ask_prices,
            &ask_volumes,
            &bid_prices,
            &bid_volumes,
            &trades,
            window,
        );

        // Define tolerance for floating point comparisons
        let tolerance = TOLERANCE;

        // Compare key features that should be identical
        assert!(
            (scalar_features.spread - simd_features.spread).abs() < tolerance,
            "Spread mismatch: scalar={}, simd={}",
            scalar_features.spread,
            simd_features.spread
        );

        assert!(
            (scalar_features.mid_price - simd_features.mid_price).abs() < tolerance,
            "Mid price mismatch: scalar={}, simd={}",
            scalar_features.mid_price,
            simd_features.mid_price
        );

        assert!(
            (scalar_features.order_imbalance - simd_features.order_imbalance).abs() < tolerance,
            "Order imbalance mismatch: scalar={}, simd={}",
            scalar_features.order_imbalance,
            simd_features.order_imbalance
        );

        assert!(
            (scalar_features.order_book_depth - simd_features.order_book_depth).abs() < tolerance,
            "Order book depth mismatch: scalar={}, simd={}",
            scalar_features.order_book_depth,
            simd_features.order_book_depth
        );

        assert!(
            (scalar_features.liquidity_shocks - simd_features.liquidity_shocks).abs() < tolerance,
            "Liquidity shocks mismatch: scalar={}, simd={}",
            scalar_features.liquidity_shocks,
            simd_features.liquidity_shocks
        );

        println!("✅ SIMD ML features correctness test passed!");
        println!(
            "Scalar spread: {}, SIMD spread: {}",
            scalar_features.spread, simd_features.spread
        );
        println!(
            "Scalar order imbalance: {}, SIMD order imbalance: {}",
            scalar_features.order_imbalance, simd_features.order_imbalance
        );
        println!(
            "Scalar depth: {}, SIMD depth: {}",
            scalar_features.order_book_depth, simd_features.order_book_depth
        );
    }

    #[test]
    fn test_volume_features_batch_correctness() {
        use vectorized_features::VectorizedFeatures;

        let mut vectorized = VectorizedFeatures::<64>::new();

        let ask_volumes = vec![ASK_QTY_100, ASK_QTY_150, ASK_QTY_200, ASK_QTY_250];

        let bid_volumes = vec![BID_QTY_120, BID_QTY_180, BID_QTY_240, BID_QTY_300];

        let batch_features = vectorized.calc_volume_features_batch(&ask_volumes, &bid_volumes);

        // Manually calculate expected values for verification
        let ask_total: f64 = 100.0 + 150.0 + 200.0 + 250.0; // 700.0
        let bid_total: f64 = 120.0 + 180.0 + 240.0 + 300.0; // 840.0
        let total_depth = ask_total + bid_total; // 1540.0

        let expected_order_imbalance = (bid_total - ask_total) / total_depth; // (840-700)/1540 ≈ 0.0909
        let expected_order_book_depth = total_depth; // 1540.0

        let tolerance = 0.0001;

        assert!(
            (batch_features.order_imbalance - expected_order_imbalance).abs() < tolerance,
            "Order imbalance mismatch: batch={}, expected={}",
            batch_features.order_imbalance,
            expected_order_imbalance
        );

        assert!(
            (batch_features.order_book_depth - expected_order_book_depth).abs() < tolerance,
            "Order book depth mismatch: batch={}, expected={}",
            batch_features.order_book_depth,
            expected_order_book_depth
        );

        println!("✅ Volume features batch correctness test passed!");
        println!("Batch order imbalance: {}", batch_features.order_imbalance);
        println!(
            "Batch order book depth: {}",
            batch_features.order_book_depth
        );
    }
}