Chaikin Oscillator

//! # Chaikin Oscillator Optimization Example
//!
//! This example demonstrates how to optimize the Chaikin Oscillator indicator
//! from the centaur_technical_indicators library using the TradingNetwork optimization framework.
//!
//! ## Indicator Type: Crossover-based Oscillator
//!
//! The Chaikin Oscillator measures the momentum of the Accumulation/Distribution line.
//! It uses the difference between fast and slow EMAs of the A/D line.
//! - **Buy signal**: Oscillator crosses above zero (accumulation/buying pressure)
//! - **Sell signal**: Oscillator crosses below zero (distribution/selling pressure)
//!
//! ## Parameters Optimized:
//! - short_period: Fast EMA period (2-125)
//! - long_period: Slow EMA period (2-125, must be > short_period)
//! - short_ma_type: Moving average model for short period (SMA, EMA, SMMA, Median, Mode)
//! - long_ma_type: Moving average model for long period (SMA, EMA, SMMA, Median, Mode)
//!
//! ## Data Requirements:
//! - High prices
//! - Low prices
//! - Close prices
//! - Volume data
//!
//! ## Usage:
//! ```bash
//! cp src/examples/chaikin_oscillator_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::chaikin_oscillator;
use centaur_technical_indicators::ConstantModelType;
use serde::Deserialize;
use std::io;
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()
}

#[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,
    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 main() {
    let data = get_data();
    println!("Extracting values from data");

    let mut high: Vec<f64> = Vec::new();
    let mut low: Vec<f64> = Vec::new();
    let mut close: Vec<f64> = Vec::new();
    let mut volume: Vec<f64> = Vec::new();

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

    for i in data.iter() {
        high.push(i.high);
        low.push(i.low);
        close.push(i.close);
        volume.push(i.volume);
    }

    let indicator_loop = Instant::now();

    // get buy and sell points, in an ideal world we would buy at the lowest point in the dip and sell at the highest point in the peak
    // In the course of a 20-day period (1 month of trading days), we want to find the highest peak and lowest valley within 5 days of each other
    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>>();

    // Define the ranges for optimization
    let max_short_period: usize = 125;
    let min_short_period: usize = 2;
    let max_long_period: usize = 125;
    let min_long_period: usize = 2;

    let fuzz_parameter: usize = 5; // Allowable distance from buy/sell points

    // Store the best parameters found
    let mut best_rating = 0.0;
    let mut best_short_period: usize = 0;
    let mut best_long_period: usize = 0;
    let mut best_long_ma_type = ConstantModelType::SimpleMovingAverage;
    let mut best_short_ma_type = ConstantModelType::SimpleMovingAverage;
    let mut best_indicators = vec![];

    let total_iterations = (max_short_period - min_short_period + 1) * (max_long_period - min_long_period + 1) * 5 * 5;
    let mut iteration_count = 0;
    println!("\nRunning optimization loop with {} total iterations...", total_iterations);

    for &long_ma_type in &[ConstantModelType::SimpleMovingAverage, ConstantModelType::ExponentialMovingAverage, ConstantModelType::SmoothedMovingAverage, ConstantModelType::SimpleMovingMedian, ConstantModelType::SimpleMovingMode] {
        for &short_ma_type in &[ConstantModelType::SimpleMovingAverage, ConstantModelType::ExponentialMovingAverage, ConstantModelType::SmoothedMovingAverage, ConstantModelType::SimpleMovingMedian, ConstantModelType::SimpleMovingMode] {
            for short_period in min_short_period..=max_short_period {
                for long_period in min_long_period..=max_long_period {
                    // Skip invalid combinations where short >= long
                    if short_period >= long_period {
                        continue;
                    }

                    iteration_count += 1;
                    if iteration_count % (total_iterations / 20).max(1) == 0 {
                        let next_log_percent = (iteration_count * 100) / total_iterations;
                        println!("Optimization is {}% complete...", next_log_percent);
                    }

                    let indicators = chaikin_oscillator(&high, &low, &close, &volume, short_period, long_period, 0.0, short_ma_type, long_ma_type)
                        .expect("Failed to calculate Chaikin Oscillator");
                    let mut rating = vec![];
                    let mut matched_sell = vec![];
                    let mut matched_buy = vec![];

                    for i in 1..indicators.len() {
                        let price_location = i + long_period; // Adjust for indicator lag
                        if price_location >= close.len() { break; }

                        // Chaikin Oscillator: positive values suggest accumulation (buying pressure), negative values suggest distribution (selling pressure)
                        // Crossovers are key signals
                        let current_value = indicators[i].0;
                        let previous_value = indicators[i - 1].0;

                        // Buy signal: Oscillator crosses above zero (accumulation)
                        if current_value > 0.0 && previous_value <= 0.0 {
                            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) {
                                        rating.push(proximity_rating(&fuzzed_location, &price_location));
                                        matched_buy.push(fuzzed_location);
                                        found_buy = true;
                                    }
                                    if sell_points.contains(&fuzzed_location) {
                                        if !matched_buy.contains(&fuzzed_location) {
                                            rating.push(-proximity_rating(&fuzzed_location, &price_location));
                                        }
                                    }
                                }
                                if !found_buy {
                                    rating.push(0.0);
                                }
                            }
                        }
                        // Sell signal: Oscillator crosses below zero (distribution)
                        else if current_value < 0.0 && previous_value >= 0.0 {
                            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) {
                                        rating.push(proximity_rating(&fuzzed_location, &price_location));
                                        matched_sell.push(fuzzed_location);
                                        found_sell = true;
                                    }
                                    if buy_points.contains(&fuzzed_location) {
                                        if !matched_sell.contains(&fuzzed_location) {
                                            rating.push(-proximity_rating(&fuzzed_location, &price_location));
                                        }
                                    }
                                }
                                if !found_sell {
                                    rating.push(0.0);
                                }
                            }
                        }
                    }

                    // Look for any missed buy/sell points and penalize
                    for missed_sell in sell_points.iter() {
                        if !matched_sell.contains(missed_sell) {
                            rating.push(-1.0);
                        }
                    }
                    for missed_buy in buy_points.iter() {
                        if !matched_buy.contains(missed_buy) {
                            rating.push(-1.0);
                        }
                    }

                    let total_rating: f64 = if rating.is_empty() {
                        0.0
                    } else {
                        rating.iter().sum::<f64>() / (rating.len() as f64)
                    };
                    if total_rating > best_rating {
                        best_rating = total_rating;
                        best_short_period = short_period;
                        best_long_period = long_period;
                        best_indicators = indicators.clone();
                        best_long_ma_type = long_ma_type;
                        best_short_ma_type = short_ma_type;
                    }
                }
            }
        }
    }

    println!(
        "Indicators optimization loop took {} ms to run",
        indicator_loop.elapsed().as_millis()
    );

    println!("\nBest Chaikin Oscillator parameters found:");
    println!("short_period = {}", best_short_period);
    println!("long_period = {}", best_long_period);
    println!("short_ma_type = {:?}", best_short_ma_type);
    println!("long_ma_type = {:?}", best_long_ma_type);
    println!("Rating: {}", best_rating);
}