McGinley Dynamic Commodity Channel Index (MDCCI)

//! # McGinley Dynamic Commodity Channel Index (MDCCI) Optimization Example
//!
//! This example demonstrates how to optimize the McGinley Dynamic CCI indicator
//! from the centaur_technical_indicators library using the TradingNetwork optimization framework.
//!
//! ## Indicator Type: Threshold-Based Oscillator
//!
//! The McGinley Dynamic CCI is an adaptive variant of CCI that uses the McGinley Dynamic
//! moving average instead of a traditional moving average. Like CCI, it oscillates around
//! zero with no fixed upper/lower bounds.
//! - **Buy signal**: MDCCI drops below oversold threshold
//! - **Sell signal**: MDCCI rises above overbought threshold
//!
//! ## Parameters Optimized:
//! - Period: 4-60
//! - Constant Multiplier: 0.005-0.030
//! - Deviation Model: StandardDeviation, MeanAbsoluteDeviation, MedianAbsoluteDeviation, ModeAbsoluteDeviation, UlcerIndex
//! - Oversold threshold: -200 to 0
//! - Overbought threshold: 0 to 200
//!
//! ## Data Requirements:
//! - High, Low, Close prices (to calculate typical price)
//!
//! ## Baseline Comparison:
//! Uses optimized CCI parameters as baseline:
//! - Period: 24, Deviation: MeanAbsoluteDeviation
//! - Constant Multiplier: 0.0080, Oversold: -12, Overbought: 148
//!
//! ## Usage:
//! ```bash
//! cp src/examples/mcginley_dynamic_cci_optimization.rs src/main.rs
//! cat src/year_spx.csv | cargo run --release
//! ```

use chrono::NaiveDate;
use centaur_technical_indicators::chart_trends::{peaks, valleys};
use centaur_technical_indicators::momentum_indicators::bulk::{mcginley_dynamic_commodity_channel_index, commodity_channel_index};
use centaur_technical_indicators::{ConstantModelType, DeviationModel};
use rayon::prelude::*;
use serde::Deserialize;
use std::io;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Instant;

fn proximity_rating(fuzzed_location: &usize, price_location: &usize) -> f64 {
    1.0 / (*fuzzed_location as f64 - *price_location as f64).abs()
}

struct OptimizationResult {
    rating: f64,
    period: usize,
    deviation_model: DeviationModel,
    constant_multiplier: f64,
    oversold: i32,
    overbought: i32,
    indicators: Vec<(f64, f64)>,
}

#[derive(Deserialize, Debug)]
struct Ohlc {
    #[serde(with = "csv_date_format")]
    #[allow(dead_code)]
    date: NaiveDate,
    #[allow(dead_code)]
    open: f64,
    high: f64,
    low: f64,
    close: f64,
    #[allow(dead_code)]
    volume: f64,
}

mod csv_date_format {
    use chrono::NaiveDate;
    use serde::{self, Deserialize, Deserializer};

    const FORMAT: &'static str = "%Y-%m-%d";

    pub fn deserialize<'de, D>(deserializer: D) -> Result<NaiveDate, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        let dt = NaiveDate::parse_from_str(&s, FORMAT).map_err(serde::de::Error::custom)?;
        Ok(dt)
    }
}

fn get_data() -> Vec<Ohlc> {
    let mut prices = Vec::new();
    let mut rdr = csv::Reader::from_reader(io::stdin());
    for line in rdr.deserialize() {
        let ohlc: Ohlc = line.expect("Failed to parse CSV line");
        prices.push(ohlc);
    }
    prices
}

fn format_duration(seconds: u64) -> String {
    let hours = seconds / 3600;
    let minutes = (seconds % 3600) / 60;
    let secs = seconds % 60;

    if hours > 0 {
        format!("{}h {}m {}s", hours, minutes, secs)
    } else if minutes > 0 {
        format!("{}m {}s", minutes, secs)
    } else {
        format!("{}s", secs)
    }
}

pub fn main() {
    let data = get_data();
    println!("Extracting values from data");

    let mut close: Vec<f64> = Vec::new();
    let mut typical_price: Vec<f64> = Vec::new();

    for i in data.iter() {
        close.push(i.close);
        // MDCCI uses typical price: (high + low + close) / 3
        typical_price.push((i.high + i.low + i.close) / 3.0);
    }

    println!("Values extracted, processing data");

    let optimization_start = Instant::now();

    // Get buy and sell points
    let sell_points = peaks(&close, 20, 5)
        .expect("Failed to calculate peaks")
        .into_iter()
        .map(|(_, i)| i)
        .collect::<Vec<usize>>();
    let buy_points = valleys(&close, 20, 5)
        .expect("Failed to calculate valleys")
        .into_iter()
        .map(|(_, i)| i)
        .collect::<Vec<usize>>();

    println!(
        "Found {} buy points and {} sell points",
        buy_points.len(),
        sell_points.len()
    );

    let max_period = 60;
    let min_period = 4;

    let oversold_values: Vec<i32> = (-200..=0).collect();
    let overbought_values: Vec<i32> = (0..=200).collect();
    let multiplier_values: Vec<i32> = (5..=30).collect(); // 0.005 to 0.030 in steps of 0.001

    let fuzz_parameter = 5;

    let deviation_models = vec![
        DeviationModel::StandardDeviation,
        DeviationModel::MeanAbsoluteDeviation,
        DeviationModel::MedianAbsoluteDeviation,
        DeviationModel::ModeAbsoluteDeviation,
        DeviationModel::UlcerIndex,
    ];

    let best_result = Arc::new(Mutex::new(OptimizationResult {
        rating: f64::NEG_INFINITY,
        period: 0,
        deviation_model: DeviationModel::StandardDeviation,
        constant_multiplier: 0.0,
        oversold: 0,
        overbought: 0,
        indicators: vec![],
    }));

    let valid_threshold_combinations = oversold_values.iter()
        .flat_map(|&oversold| {
            overbought_values.iter().filter(move |&&overbought| oversold < overbought)
        })
        .count();

    let total_iterations = valid_threshold_combinations
        * multiplier_values.len()
        * deviation_models.len()
        * (max_period - min_period + 1);

    println!(
        "
Running parallel optimization with {} total iterations...",
        total_iterations
    );
    println!("Using {} threads", rayon::current_num_threads());

    let iteration_count = Arc::new(AtomicUsize::new(0));
    let last_logged_percent = Arc::new(AtomicUsize::new(0));

    let threshold_pairs: Vec<(i32, i32)> = oversold_values.iter()
        .flat_map(|&oversold| {
            overbought_values.iter()
                .filter(move |&&overbought| oversold < overbought)
                .map(move |&overbought| (oversold, overbought))
        })
        .collect();

    threshold_pairs.par_iter().for_each(|&(oversold, overbought)| {
        for &multiplier_int in &multiplier_values {
            let multiplier = multiplier_int as f64 / 1000.0;
            for &deviation_type in &deviation_models {
                for period in min_period..=max_period {
                    if typical_price.len() < period + 2 {
                        continue;
                    }

                    // MDCCI returns Vec<(f64, f64)> where .0 is CCI value, .1 is McGinley Dynamic
                    let indicators = match mcginley_dynamic_commodity_channel_index(
                        &typical_price,
                        0.0,
                        deviation_type,
                        multiplier,
                        period,
                    ) {
                        Ok(ind) => ind,
                        Err(_) => continue,
                    };

                    let mut rating = vec![];
                    let mut matched_sell = vec![];
                    let mut matched_buy = vec![];

                    for i in 0..indicators.len() {
                        let price_location = i + period;
                        if price_location >= close.len() {
                            break;
                        }

                        let mdcci_value = indicators[i].0; // Use the CCI value from the tuple

                        if mdcci_value > overbought as f64 {
                            if sell_points.contains(&price_location) {
                                rating.push(1.0);
                                matched_sell.push(price_location);
                            } else if buy_points.contains(&price_location) {
                                rating.push(-1.0);
                            } else {
                                let mut found_sell = false;
                                for fuzzed_location in price_location.saturating_sub(fuzz_parameter)
                                    ..=price_location + fuzz_parameter
                                {
                                    if sell_points.contains(&fuzzed_location)
                                        && !matched_sell.contains(&fuzzed_location)
                                    {
                                        rating.push(proximity_rating(
                                            &fuzzed_location,
                                            &price_location,
                                        ));
                                        matched_sell.push(fuzzed_location);
                                        found_sell = true;
                                        break;
                                    }
                                }
                                if !found_sell {
                                    for fuzzed_location in price_location.saturating_sub(fuzz_parameter)
                                        ..=price_location + fuzz_parameter
                                    {
                                        if buy_points.contains(&fuzzed_location) {
                                            rating.push(-proximity_rating(
                                                &fuzzed_location,
                                                &price_location,
                                            ));
                                            break;
                                        }
                                    }
                                }
                            }
                        } else if mdcci_value < oversold as f64 {
                            if buy_points.contains(&price_location) {
                                rating.push(1.0);
                                matched_buy.push(price_location);
                            } else if sell_points.contains(&price_location) {
                                rating.push(-1.0);
                            } else {
                                let mut found_buy = false;
                                for fuzzed_location in price_location.saturating_sub(fuzz_parameter)
                                    ..=price_location + fuzz_parameter
                                {
                                    if buy_points.contains(&fuzzed_location)
                                        && !matched_buy.contains(&fuzzed_location)
                                    {
                                        rating.push(proximity_rating(
                                            &fuzzed_location,
                                            &price_location,
                                        ));
                                        matched_buy.push(fuzzed_location);
                                        found_buy = true;
                                        break;
                                    }
                                }
                                if !found_buy {
                                    for fuzzed_location in price_location.saturating_sub(fuzz_parameter)
                                        ..=price_location + fuzz_parameter
                                    {
                                        if sell_points.contains(&fuzzed_location) {
                                            rating.push(-proximity_rating(
                                                &fuzzed_location,
                                                &price_location,
                                            ));
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }

                    for &missed_sell in &sell_points {
                        if !matched_sell.contains(&missed_sell) {
                            rating.push(-1.0);
                        }
                    }
                    for &missed_buy in &buy_points {
                        if !matched_buy.contains(&missed_buy) {
                            rating.push(-1.0);
                        }
                    }

                    if !rating.is_empty() {
                        let total_rating: f64 =
                            rating.iter().sum::<f64>() / (rating.len() as f64);

                        let mut best = best_result.lock().unwrap();
                        if total_rating > best.rating {
                            best.rating = total_rating;
                            best.period = period;
                            best.deviation_model = deviation_type;
                            best.constant_multiplier = multiplier;
                            best.oversold = oversold;
                            best.overbought = overbought;
                            best.indicators = indicators;
                        }
                    }

                    let current_count = iteration_count.fetch_add(1, Ordering::Relaxed) + 1;
                    let current_percent = (current_count * 100) / total_iterations;
                    let last_percent = last_logged_percent.load(Ordering::Relaxed);

                    if current_percent > last_percent && current_percent % 5 == 0 {
                        if last_logged_percent
                            .compare_exchange(last_percent, current_percent, Ordering::Relaxed, Ordering::Relaxed)
                            .is_ok()
                        {
                            let elapsed = optimization_start.elapsed().as_secs();
                            let estimated_total = if current_count > 0 {
                                (elapsed * total_iterations as u64) / current_count as u64
                            } else {
                                0
                            };
                            let estimated_remaining = estimated_total.saturating_sub(elapsed);

                            println!(
                                "Optimization is {}% complete... (Elapsed: {}, Est. remaining: {})",
                                current_percent,
                                format_duration(elapsed),
                                format_duration(estimated_remaining)
                            );
                        }
                    }
                }
            }
        }
    });

    let optimization_elapsed = optimization_start.elapsed();
    println!(
        "
Optimization complete in {}",
        format_duration(optimization_elapsed.as_secs())
    );

    let best = best_result.lock().unwrap();
    println!("
Best McGinley Dynamic CCI parameters found:");
    println!("Period: {}", best.period);
    println!("Deviation Model: {:?}", best.deviation_model);
    println!("Constant Multiplier: {:.4}", best.constant_multiplier);
    println!("Oversold threshold: {}", best.oversold);
    println!("Overbought threshold: {}", best.overbought);
    println!("Rating: {:.4}", best.rating);
}