moving_average_cpp.cpp

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <chrono>
#include <numeric>
#include <deque>

struct Candlestick {
    std::string timestamp;
    double open;
    double high;
    double low;
    double close;
    double volume;
};

std::vector<Candlestick> readCSV(const std::string& filename) {
    std::vector<Candlestick> data;
    std::ifstream file(filename);
    std::string line;
    
    // Skip header
    std::getline(file, line);
    
    while (std::getline(file, line)) {
        std::stringstream ss(line);
        std::string cell;
        std::vector<std::string> row;
        
        while (std::getline(ss, cell, ',')) {
            row.push_back(cell);
        }
        
        if (row.size() >= 6) {
            Candlestick candle;
            candle.timestamp = row[0];
            candle.open = std::stod(row[1]);
            candle.high = std::stod(row[2]);
            candle.low = std::stod(row[3]);
            candle.close = std::stod(row[4]);
            candle.volume = std::stod(row[5]);
            data.push_back(candle);
        }
    }
    
    return data;
}

std::vector<double> calculateMovingAverage(const std::vector<Candlestick>& data, int period) {
    std::vector<double> ma;
    if (data.size() < period) {
        return ma;
    }
    
    // Calculate initial sum for the first window
    double sum = 0.0;
    for (int i = 0; i < period; ++i) {
        sum += data[i].close;
    }
    ma.push_back(sum / period);
    
    // Use sliding window technique for efficiency
    for (size_t i = period; i < data.size(); ++i) {
        sum = sum - data[i - period].close + data[i].close;
        ma.push_back(sum / period);
    }
    
    return ma;
}

std::vector<double> calculateComplexMath(const std::vector<Candlestick>& data) {
    std::vector<double> result;
    result.reserve(data.size());
    
    for (const auto& candle : data) {
        // Complex mathematical function: weighted combination of OHLC values
        double value = (candle.open * 0.1) + (candle.high * 0.3) + (candle.low * 0.2) + (candle.close * 0.4);
        // Apply exponential and logarithmic transformations
        value = std::exp(value / 100.0) * std::log(std::abs(value) + 1.0);
        result.push_back(value);
    }
    
    return result;
}

int main() {
    auto start_time = std::chrono::high_resolution_clock::now();
    
    std::cout << "Reading CSV file..." << std::endl;
    std::vector<Candlestick> data = readCSV("USDJPY2.csv");
    std::cout << "Loaded " << data.size() << " records." << std::endl;
    
    // Calculate multiple moving averages
    std::cout << "Calculating 50-period MA..." << std::endl;
    auto ma50 = calculateMovingAverage(data, 50);
    std::cout << "Calculated " << ma50.size() << " MA50 values." << std::endl;
    
    std::cout << "Calculating 200-period MA..." << std::endl;
    auto ma200 = calculateMovingAverage(data, 200);
    std::cout << "Calculated " << ma200.size() << " MA200 values." << std::endl;
    
    std::cout << "Calculating 500-period MA..." << std::endl;
    auto ma500 = calculateMovingAverage(data, 500);
    std::cout << "Calculated " << ma500.size() << " MA500 values." << std::endl;
    
    // Perform complex mathematical operations
    std::cout << "Performing complex mathematical operations..." << std::endl;
    auto complexResults = calculateComplexMath(data);
    std::cout << "Completed " << complexResults.size() << " complex calculations." << std::endl;
    
    auto end_time = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
    
    std::cout << "Total execution time: " << duration.count() << " ms" << std::endl;
    
    return 0;
}