FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// src/algo_engine/BacktestEngine.cpp
#include "algo_engine/BacktestEngine.h"
#include "algo_engine/ConditionEvaluator.h"
#include "core/logging/Logger.h"
#include <QDateTime>
#include <algorithm>
#include <cmath>
namespace fincept::algo {
namespace {
// Bars required before any evaluation (indicator warm-up). Matches the old
// Python engine's WARMUP_BARS so results are comparable in shape.
constexpr int kWarmupBars = 50;
// Trailing window passed to the indicator/condition evaluator each bar. Bounds
// per-bar cost to O(window) instead of O(i) — 500 bars is ample warm-up for any
// indicator in the catalog (largest typical period ~200).
constexpr int kEvalWindow = 500;
double round_to(double v, int decimals) {
double f = std::pow(10.0, decimals);
return std::round(v * f) / f;
}
// Bars per year for timeframe-aware Sharpe annualisation (mirrors the old engine).
double bars_per_year(const QString& tf) {
if (tf == "1m")
return 252.0 * 390.0;
if (tf == "3m")
return 252.0 * 130.0;
if (tf == "5m")
return 252.0 * 78.0;
if (tf == "10m")
return 252.0 * 39.0;
if (tf == "15m")
return 252.0 * 26.0;
if (tf == "30m")
return 252.0 * 13.0;
if (tf == "1h")
return 252.0 * 6.5;
if (tf == "4h")
return 252.0 * 1.625;
if (tf == "1d")
return 252.0;
return 252.0;
}
} // namespace
QJsonObject BacktestEngine::run(const QVector<OhlcvCandle>& candles, const QJsonArray& entry_conditions,
const QString& entry_logic, const QJsonArray& exit_conditions,
const QString& exit_logic, double stop_loss_pct, double take_profit_pct,
double trailing_stop_pct, double initial_capital, const QString& timeframe,
double position_size_pct) {
const int n = candles.size();
const double size_frac = std::clamp(position_size_pct, 1.0, 100.0) / 100.0;
if (n < kWarmupBars + 10) {
QJsonObject err;
err["success"] = false;
err["error"] = QString("Insufficient data: %1 candles (need at least %2)").arg(n).arg(kWarmupBars + 10);
return err;
}
LOG_INFO("Backtest", QString("run: candles=%1 tf=%2 entryConds=%3 exitConds=%4 sl=%5 tp=%6 sizePct=%7")
.arg(n)
.arg(timeframe)
.arg(entry_conditions.size())
.arg(exit_conditions.size())
.arg(stop_loss_pct)
.arg(take_profit_pct)
.arg(position_size_pct));
// ── Diagnostics ──────────────────────────────────────────────────────────
int entry_eval_count = 0, entry_true_count = 0, exit_true_count = 0, entry_err_count = 0;
QString last_entry_err;
bool entry_sampled = false;
double cash = initial_capital;
bool in_pos = false;
double entry_price = 0.0;
int entry_bar = 0;
long long shares = 0;
double highest = 0.0; // high-watermark for trailing stop (long)
// Signals latched on the close of bar i, executed at the open of bar i+1.
bool entry_signal = false;
bool exit_signal = false;
QJsonArray trades;
QVector<double> equity_curve;
equity_curve.reserve(n - kWarmupBars);
// Buy-&-hold benchmark: invest all capital at the first evaluated bar's close.
QVector<double> benchmark_curve;
benchmark_curve.reserve(n - kWarmupBars);
const double bench_base = candles[kWarmupBars].close;
double peak_equity = initial_capital;
double max_dd = 0.0;
auto close_trade = [&](double exit_price, const char* reason, int exit_bar) {
const double pnl = (exit_price - entry_price) * static_cast<double>(shares);
const double pnl_pct = entry_price > 0 ? (exit_price - entry_price) / entry_price * 100.0 : 0.0;
cash += static_cast<double>(shares) * exit_price;
QJsonObject t;
t["entry_bar"] = entry_bar;
t["exit_bar"] = exit_bar;
t["entry_price"] = round_to(entry_price, 2);
t["exit_price"] = round_to(exit_price, 2);
t["shares"] = static_cast<double>(shares);
t["pnl"] = round_to(pnl, 2);
t["pnl_pct"] = round_to(pnl_pct, 2);
t["reason"] = QString::fromLatin1(reason);
t["bars_held"] = exit_bar - entry_bar;
trades.append(t);
in_pos = false;
shares = 0;
};
for (int i = kWarmupBars; i < n; ++i) {
const OhlcvCandle& bar = candles[i];
// ── 1. Execute pending signal fills at THIS bar's open ──────────────
if (!in_pos && entry_signal) {
const double px = bar.open;
const long long qty = px > 0 ? static_cast<long long>(std::floor(cash * size_frac / px)) : 0;
if (qty > 0) {
in_pos = true;
entry_price = px;
entry_bar = i;
shares = qty;
cash -= static_cast<double>(shares) * px;
highest = px;
}
entry_signal = false;
} else if (in_pos && exit_signal) {
close_trade(bar.open, "exit_signal", i);
exit_signal = false;
}
// ── 2. Intrabar stop-loss / take-profit on THIS bar ─────────────────
if (in_pos) {
highest = std::max(highest, bar.high);
bool have_stop = false;
double stop_price = 0.0;
if (stop_loss_pct > 0) {
stop_price = entry_price * (1.0 - stop_loss_pct / 100.0);
have_stop = true;
}
if (trailing_stop_pct > 0) {
const double trail = highest * (1.0 - trailing_stop_pct / 100.0);
stop_price = have_stop ? std::max(stop_price, trail) : trail;
have_stop = true;
}
const double tp_price = take_profit_pct > 0 ? entry_price * (1.0 + take_profit_pct / 100.0) : 0.0;
// Stop checked first (conservative when both touched in one bar). A bar that
// GAPS below the stop opens through it — a resting stop order fills at the
// open there, not at the (better) stop price, so cap the fill at bar.open.
if (have_stop && bar.low <= stop_price) {
close_trade(std::min(stop_price, bar.open), "stop_loss", i);
} else if (take_profit_pct > 0 && bar.high >= tp_price) {
close_trade(tp_price, "take_profit", i);
}
}
// ── 3. Evaluate conditions on close of bar i → latch for next bar ───
const int start = std::max(0, i - kEvalWindow + 1);
const QVector<OhlcvCandle> window = candles.mid(start, i - start + 1);
if (!in_pos && !entry_signal && !entry_conditions.isEmpty()) {
const auto g = ConditionEvaluator::evaluate_group(entry_conditions, entry_logic, window);
++entry_eval_count;
if (g.triggered) {
entry_signal = true;
++entry_true_count;
}
for (const auto& d : g.details)
if (!d.error.isEmpty()) {
++entry_err_count;
if (last_entry_err.isEmpty())
last_entry_err = d.error;
}
// Snapshot the first evaluation where the LHS operand is actually computed
// (past indicator warm-up) so we can see real operand values vs targets.
if (!entry_sampled && !g.details.isEmpty() && !std::isnan(g.details.first().computed_value)) {
entry_sampled = true;
for (const auto& d : g.details)
LOG_INFO("Backtest", QString(" entry[bar %1] %2.%3 %4 lhs=%5 rhs=%6 met=%7 err=%8")
.arg(i)
.arg(d.indicator, d.field, d.op)
.arg(d.computed_value)
.arg(d.target_value)
.arg(d.met ? QStringLiteral("Y") : QStringLiteral("N"))
.arg(d.error));
}
} else if (in_pos && !exit_signal && !exit_conditions.isEmpty()) {
if (ConditionEvaluator::evaluate_group(exit_conditions, exit_logic, window).triggered) {
exit_signal = true;
++exit_true_count;
}
}
// ── 4. Mark-to-market equity on close ───────────────────────────────
const double equity = cash + (in_pos ? static_cast<double>(shares) * bar.close : 0.0);
equity_curve.append(equity);
benchmark_curve.append(bench_base > 0 ? initial_capital * bar.close / bench_base : initial_capital);
if (equity > peak_equity)
peak_equity = equity;
const double dd = peak_equity > 0 ? (peak_equity - equity) / peak_equity * 100.0 : 0.0;
if (dd > max_dd)
max_dd = dd;
}
// Close any open position at the last bar's close.
if (in_pos)
close_trade(candles[n - 1].close, "end_of_data", n - 1);
LOG_INFO("Backtest", QString("done: evalBars=%1 entryTrue=%2 exitTrue=%3 entryErr=%4 trades=%5 lastErr='%6'")
.arg(entry_eval_count)
.arg(entry_true_count)
.arg(exit_true_count)
.arg(entry_err_count)
.arg(trades.size())
.arg(last_entry_err));
// ── Metrics ─────────────────────────────────────────────────────────────
const int total_trades = trades.size();
const double final_value = cash;
const double total_return = final_value - initial_capital;
const double total_return_pct = initial_capital > 0 ? total_return / initial_capital * 100.0 : 0.0;
QJsonObject out;
out["success"] = true;
if (total_trades == 0) {
out["total_trades"] = 0;
out["winning_trades"] = 0;
out["losing_trades"] = 0;
out["win_rate"] = 0.0;
out["total_return"] = round_to(total_return_pct, 2);
out["total_return_abs"] = round_to(total_return, 2);
out["final_value"] = round_to(final_value, 2);
out["max_drawdown"] = round_to(max_dd, 2);
out["avg_pnl"] = 0.0;
out["avg_bars_held"] = 0.0;
out["profit_factor"] = 0.0;
out["sharpe_ratio"] = 0.0;
out["sharpe"] = 0.0;
out["sortino"] = 0.0;
out["calmar"] = 0.0;
out["expectancy"] = 0.0;
out["equity_curve"] = QJsonArray();
out["benchmark_curve"] = QJsonArray();
out["benchmark_return"] = 0.0;
out["monthly_returns"] = QJsonArray();
out["trades"] = trades;
return out;
}
int wins = 0;
double gross_profit = 0.0, gross_loss = 0.0, sum_pnl = 0.0;
long long sum_bars_held = 0;
for (const auto& tv : trades) {
const QJsonObject t = tv.toObject();
const double pnl = t.value("pnl").toDouble();
sum_pnl += pnl;
sum_bars_held += t.value("bars_held").toInt();
if (pnl > 0) {
++wins;
gross_profit += pnl;
} else {
gross_loss += std::abs(pnl);
}
}
const int losses = total_trades - wins;
const double win_rate = static_cast<double>(wins) / total_trades * 100.0;
const double avg_pnl = sum_pnl / total_trades;
const double avg_bars_held = static_cast<double>(sum_bars_held) / total_trades;
double profit_factor;
if (gross_loss > 0)
profit_factor = gross_profit / gross_loss;
else
profit_factor = gross_profit > 0 ? 999.99 : 0.0;
if (profit_factor > 999.99)
profit_factor = 999.99;
// Sharpe & Sortino from equity-curve point-to-point returns, annualised by
// timeframe. Calmar = annualised-ish return over max drawdown.
double sharpe = 0.0;
double sortino = 0.0;
if (equity_curve.size() > 1) {
QVector<double> rets;
rets.reserve(equity_curve.size() - 1);
for (int i = 1; i < equity_curve.size(); ++i) {
if (equity_curve[i - 1] != 0.0)
rets.append((equity_curve[i] - equity_curve[i - 1]) / equity_curve[i - 1]);
}
if (!rets.isEmpty()) {
double mean = 0.0;
for (double r : rets)
mean += r;
mean /= rets.size();
double var = 0.0, dvar = 0.0;
for (double r : rets) {
var += (r - mean) * (r - mean);
if (r < 0.0)
dvar += r * r; // downside-only second moment
}
var /= rets.size();
dvar /= rets.size();
const double sd = std::sqrt(var);
const double dsd = std::sqrt(dvar);
const double ann = std::sqrt(bars_per_year(timeframe));
if (sd > 0.0)
sharpe = (mean / sd) * ann;
if (dsd > 0.0)
sortino = (mean / dsd) * ann;
}
}
const double calmar = (max_dd > 0.0) ? (total_return_pct / max_dd) : 0.0;
// Downsample equity + buy-&-hold benchmark to <= 500 aligned points (keep last).
QJsonArray equity_out, benchmark_out;
{
const int sz = equity_curve.size();
const int step = sz > 500 ? sz / 500 : 1;
for (int i = 0; i < sz; i += step) {
equity_out.append(round_to(equity_curve[i], 2));
benchmark_out.append(round_to(benchmark_curve[i], 2));
}
if (sz > 0 && equity_out.last().toDouble() != round_to(equity_curve.last(), 2)) {
equity_out.append(round_to(equity_curve.last(), 2));
benchmark_out.append(round_to(benchmark_curve.last(), 2));
}
}
// Per-calendar-month returns of the strategy equity (for the heatmap).
QJsonArray monthly_returns;
{
QString cur_month;
bool have_month = false;
double month_end = initial_capital;
double prev_month_end = initial_capital;
auto flush = [&](const QString& label) {
const double ret = prev_month_end > 0 ? (month_end - prev_month_end) / prev_month_end * 100.0 : 0.0;
QJsonObject m;
m["month"] = label;
m["return"] = round_to(ret, 2);
monthly_returns.append(m);
prev_month_end = month_end;
};
for (int j = 0; j < equity_curve.size(); ++j) {
const QString ym =
QDateTime::fromMSecsSinceEpoch(candles[kWarmupBars + j].open_time, QTimeZone::UTC).toString("yyyy-MM");
if (have_month && ym != cur_month)
flush(cur_month);
cur_month = ym;
have_month = true;
month_end = equity_curve[j];
}
if (have_month)
flush(cur_month);
}
const double bench_final = benchmark_curve.isEmpty() ? initial_capital : benchmark_curve.last();
const double bench_return_pct =
initial_capital > 0 ? (bench_final - initial_capital) / initial_capital * 100.0 : 0.0;
out["total_trades"] = total_trades;
out["winning_trades"] = wins;
out["losing_trades"] = losses;
out["win_rate"] = round_to(win_rate, 1);
out["total_return"] = round_to(total_return_pct, 2); // panel reads as percent
out["total_return_abs"] = round_to(total_return, 2);
out["final_value"] = round_to(final_value, 2);
out["max_drawdown"] = round_to(max_dd, 2);
out["avg_pnl"] = round_to(avg_pnl, 2);
out["avg_bars_held"] = round_to(avg_bars_held, 1);
out["profit_factor"] = round_to(profit_factor, 2);
out["sharpe_ratio"] = round_to(sharpe, 3); // panel reads sharpe_ratio
out["sharpe"] = round_to(sharpe, 3); // alias
out["sortino"] = round_to(sortino, 3);
out["calmar"] = round_to(calmar, 2);
out["expectancy"] = round_to(avg_pnl, 2); // avg P&L per trade
out["equity_curve"] = equity_out;
out["benchmark_curve"] = benchmark_out;
out["benchmark_return"] = round_to(bench_return_pct, 2);
out["monthly_returns"] = monthly_returns;
out["trades"] = trades;
return out;
}
} // namespace fincept::algo