regime_filtered_backtester.cpp

Go to the documentation of this file.

/// @file src/backtest/regime_filtered_backtester.cpp
/// @brief Implementation of RegimeFilteredBacktester.
///
/// Runs three strategies side by side:
///   1. Always-in (unfiltered)
///   2. TIMELIKE-only (flat during SPACELIKE/LIGHTLIKE bars)
///   3. Relativistic TIMELIKE-only (gamma-scaled position, TIMELIKE only)
///
/// Key research finding reproduced here:
///   TIMELIKE bars exhibit 1.27x lower next-bar return variance than SPACELIKE.
 
#include "srfm/backtest.hpp"
#include "srfm/constants.hpp"
#include "srfm/lorentz/lorentz_transform.hpp"
 
#include <cmath>
#include <numeric>
#include <sstream>
#include <span>
#include <vector>
 
namespace srfm::backtest {
 
// ── RegimeBacktestResult::to_string ──────────────────────────────────────────
 
std::string RegimeBacktestResult::to_string() const {
    std::ostringstream ss;
    ss << "=== Regime-Filtered Backtest Results ===\n";
    ss << "\n";
    ss << "Bar classification:\n";
    ss << "  TIMELIKE:  " << (timelike_fraction  * 100.0) << "%\n";
    ss << "  LIGHTLIKE: " << (lightlike_fraction * 100.0) << "%\n";
    ss << "  SPACELIKE: " << (spacelike_fraction * 100.0) << "%\n";
    ss << "\n";
    ss << "Next-bar return variance by regime:\n";
    ss << "  TIMELIKE  variance: " << timelike_variance  << "\n";
    ss << "  SPACELIKE variance: " << spacelike_variance << "\n";
    if (spacelike_variance > 1e-12) {
        ss << "  Variance ratio (SPACELIKE/TIMELIKE): "
           << (spacelike_variance / timelike_variance) << "x\n";
    }
    ss << "\n";
    ss << "Strategy comparison:\n";
    ss << "                    Sharpe    Sortino   MaxDD     Gamma-IR\n";
    auto fmt_row = [&](const char* name, const PerformanceMetrics& m) {
        ss << "  " << name;
        ss << "  " << m.sharpe_ratio;
        ss << "  " << m.sortino_ratio;
        ss << "  " << m.max_drawdown;
        ss << "  " << m.gamma_weighted_ir << "\n";
    };
    fmt_row("Always-In          ", always_in);
    fmt_row("TIMELIKE-Only      ", timelike_only);
    fmt_row("TIMELIKE-Rel(γ-sz) ", timelike_relativistic);
    ss << "\n";
    ss << "TIMELIKE Sharpe lift vs always-in: "
       << timelike_sharpe_lift() << "\n";
    return ss.str();
}
 
// ── RegimeFilteredBacktester ──────────────────────────────────────────────────
 
RegimeFilteredBacktester::RegimeFilteredBacktester(BacktestConfig config)
    : config_(config)
    , adjuster_(config.effective_mass)
{}
 
std::optional<RegimeBacktestResult>
RegimeFilteredBacktester::run(std::span<const BarDataEx> bars) const noexcept {
    if (bars.size() < constants::MIN_RETURN_SERIES_LENGTH) {
        return std::nullopt;
    }
 
    const std::size_t n = bars.size();
 
    // ── Classify each bar by regime ─────────────────────────────────────────
    std::size_t timelike_count  = 0;
    std::size_t lightlike_count = 0;
    std::size_t spacelike_count = 0;
 
    // Collect returns by regime for variance calculation
    std::vector<double> timelike_returns;
    std::vector<double> spacelike_returns;
    timelike_returns.reserve(n);
    spacelike_returns.reserve(n);
 
    // Strategy return vectors
    std::vector<double> always_in_rets(n);
    std::vector<double> timelike_rets(n, 0.0);
    std::vector<double> timelike_rel_rets(n, 0.0);
    std::vector<double> benchmark_rets(n);
 
    // Gamma factors for performance metrics (always-in uses unit gamma)
    std::vector<double> unit_gammas(n, 1.0);
    std::vector<double> timelike_gammas(n, 1.0);
 
    for (std::size_t i = 0; i < n; ++i) {
        const auto& bar = bars[i];
        const double ret = bar.asset_return;
        const double raw_sign = (bar.base.raw_signal >= 0.0) ? 1.0 : -1.0;
 
        benchmark_rets[i] = bar.base.benchmark;
 
        // Compute gamma from beta
        double gamma_i = 1.0;
        auto g = lorentz::LorentzTransform::gamma(bar.base.beta);
        if (g.has_value()) {
            gamma_i = g->value;
        }
        const double gamma_capped =
            std::max(1.0, std::min(gamma_i, config_.max_gamma));
 
        // Classify regime
        const bool is_timelike  = bar.ds2 < -LIGHTLIKE_EPSILON;
        const bool is_lightlike = std::abs(bar.ds2) <= LIGHTLIKE_EPSILON;
        const bool is_spacelike = bar.ds2 >  LIGHTLIKE_EPSILON;
 
        if (is_timelike) {
            ++timelike_count;
            timelike_returns.push_back(ret);
        } else if (is_lightlike) {
            ++lightlike_count;
        } else if (is_spacelike) {
            ++spacelike_count;
            spacelike_returns.push_back(ret);
        }
 
        // Strategy 1: always-in (unit position)
        always_in_rets[i] = raw_sign * ret;
 
        // Strategies 2 & 3: only active on TIMELIKE bars
        if (is_timelike) {
            timelike_rets[i]     = raw_sign * ret;
            timelike_rel_rets[i] = raw_sign * gamma_capped * ret;
            timelike_gammas[i]   = gamma_capped;
        }
        // else: 0.0 (flat, no position)
    }
 
    // ── Compute per-regime variance ─────────────────────────────────────────
    auto variance_of = [](const std::vector<double>& v) -> double {
        if (v.size() < 2) return 0.0;
        const double mean =
            std::accumulate(v.begin(), v.end(), 0.0) / static_cast<double>(v.size());
        double sq_sum = 0.0;
        for (double x : v) {
            const double d = x - mean;
            sq_sum += d * d;
        }
        return sq_sum / static_cast<double>(v.size() - 1);
    };
 
    const double tv = variance_of(timelike_returns);
    const double sv = variance_of(spacelike_returns);
 
    // ── Compute performance metrics for each strategy ───────────────────────
    // Helper: use the existing PerformanceCalculator from Backtester
    auto calc_metrics = [&](
        std::span<const double> rets,
        std::span<const double> bench,
        std::span<const double> gammas
    ) -> std::optional<PerformanceMetrics> {
        auto sh = PerformanceCalculator::sharpe(
            rets, config_.risk_free_rate, config_.annualisation);
        if (!sh) return std::nullopt;
 
        auto so = PerformanceCalculator::sortino(
            rets, config_.risk_free_rate, config_.annualisation);
        if (!so) return std::nullopt;
 
        auto mdd = PerformanceCalculator::max_drawdown(rets);
        if (!mdd) return std::nullopt;
 
        auto ir = PerformanceCalculator::gamma_weighted_ir(rets, bench, gammas);
        if (!ir) return std::nullopt;
 
        return PerformanceMetrics{
            .sharpe_ratio      = *sh,
            .sortino_ratio     = *so,
            .max_drawdown      = *mdd,
            .gamma_weighted_ir = *ir,
        };
    };
 
    auto always_metrics = calc_metrics(always_in_rets, benchmark_rets, unit_gammas);
    if (!always_metrics) return std::nullopt;
 
    auto timelike_metrics = calc_metrics(timelike_rets, benchmark_rets, timelike_gammas);
    if (!timelike_metrics) return std::nullopt;
 
    auto timelike_rel_metrics = calc_metrics(timelike_rel_rets, benchmark_rets, timelike_gammas);
    if (!timelike_rel_metrics) return std::nullopt;
 
    const double nd = static_cast<double>(n);
    return RegimeBacktestResult{
        .always_in             = *always_metrics,
        .timelike_only         = *timelike_metrics,
        .timelike_relativistic = *timelike_rel_metrics,
        .timelike_fraction     = static_cast<double>(timelike_count)  / nd,
        .spacelike_fraction    = static_cast<double>(spacelike_count) / nd,
        .lightlike_fraction    = static_cast<double>(lightlike_count) / nd,
        .timelike_variance     = tv,
        .spacelike_variance    = sv,
    };
}
 
}  // namespace srfm::backtest