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/IndicatorEngine.cpp
#include "algo_engine/IndicatorEngine.h"
#include <algorithm>
#include <cmath>
#include <limits>
#include <numeric>
namespace fincept::algo {
// ── Helpers ─────────────────────────────────────────────────────────────────
void IndicatorEngine::extract_arrays(const QVector<OhlcvCandle>& candles, QVector<double>& open, QVector<double>& high,
QVector<double>& low, QVector<double>& close, QVector<double>& volume) {
const int n = candles.size();
open.resize(n);
high.resize(n);
low.resize(n);
close.resize(n);
volume.resize(n);
for (int i = 0; i < n; ++i) {
open[i] = candles[i].open;
high[i] = candles[i].high;
low[i] = candles[i].low;
close[i] = candles[i].close;
volume[i] = candles[i].volume;
}
}
// Both helpers emit a series whose first period-1 samples are NaN, and callers
// feed exactly such a series straight back in (Stochastic's %D over %K, MACD's
// signal line over the MACD line, DEMA/TEMA's EMA of an EMA). Seeding the
// window at index 0 pulls those NaNs into the running sum, and a NaN never
// leaves a rolling sum or an EMA recursion again, so the whole output is NaN
// however long the input is. Seed from the first finite sample instead.
static int first_finite(const QVector<double>& src) {
const int n = src.size();
int i = 0;
while (i < n && !std::isfinite(src[i]))
++i;
return i;
}
QVector<double> IndicatorEngine::sma_series(const QVector<double>& src, int period) {
const int n = src.size();
QVector<double> out(n, std::numeric_limits<double>::quiet_NaN());
const int start = first_finite(src);
if (n - start < period)
return out;
double sum = 0;
for (int i = start; i < start + period; ++i)
sum += src[i];
out[start + period - 1] = sum / period;
for (int i = start + period; i < n; ++i) {
sum += src[i] - src[i - period];
out[i] = sum / period;
}
return out;
}
QVector<double> IndicatorEngine::ema_series(const QVector<double>& src, int period) {
const int n = src.size();
QVector<double> out(n, std::numeric_limits<double>::quiet_NaN());
const int start = first_finite(src);
if (n - start < period)
return out;
double sum = 0;
for (int i = start; i < start + period; ++i)
sum += src[i];
out[start + period - 1] = sum / period;
double mult = 2.0 / (period + 1);
for (int i = start + period; i < n; ++i)
out[i] = (src[i] - out[i - 1]) * mult + out[i - 1];
return out;
}
QVector<double> IndicatorEngine::true_range_series(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close) {
const int n = high.size();
QVector<double> tr(n, 0);
if (n > 0)
tr[0] = high[0] - low[0];
for (int i = 1; i < n; ++i) {
double hl = high[i] - low[i];
double hc = std::abs(high[i] - close[i - 1]);
double lc = std::abs(low[i] - close[i - 1]);
tr[i] = std::max({hl, hc, lc});
}
return tr;
}
static IndicatorResult make_result(double curr, double prev) {
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("value")] = curr;
r.previous[QStringLiteral("value")] = prev;
return r;
}
static IndicatorResult make_error(const QString& msg) {
IndicatorResult r;
r.error = msg;
return r;
}
// ── Dispatch ────────────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute(const QString& name, const QVector<OhlcvCandle>& candles,
const QJsonObject& params, const QString& /*field*/) {
if (candles.size() < 2)
return make_error(QStringLiteral("Insufficient data"));
// Stock attributes
if (name == "CLOSE" || name == "OPEN" || name == "HIGH" || name == "LOW" || name == "VOLUME" || name == "VWAP")
return compute_stock_attr(candles, name);
QVector<double> open, high, low, close, vol;
extract_arrays(candles, open, high, low, close, vol);
// Period/window parameters are divisors *and* array offsets throughout this
// file (`sum / period`, `out[period - 1]`, `src[i - period]`, `2/(period+1)`).
// A zero or negative period from a malformed strategy therefore produces both
// ±inf — which is not NaN, so it survives the evaluator's guards — and
// out-of-bounds indexing. Clamp once here instead of in every compute_*.
auto at_least_one = [](int v) { return v >= 1 ? v : 1; };
int period = at_least_one(params.value("period").toInt(14));
// Moving averages
if (name == "SMA")
return compute_sma(close, period);
if (name == "EMA")
return compute_ema(close, period);
if (name == "WMA")
return compute_wma(close, period);
if (name == "DEMA")
return compute_dema(close, period);
if (name == "TEMA")
return compute_tema(close, period);
// Momentum
if (name == "RSI")
return compute_rsi(close, period);
if (name == "MACD") {
int fast = at_least_one(params.value("fast").toInt(12));
int slow = at_least_one(params.value("slow").toInt(26));
int sig = at_least_one(params.value("signal").toInt(9));
return compute_macd(close, fast, slow, sig);
}
if (name == "STOCHASTIC") {
int k = at_least_one(params.value("k_period").toInt(14));
int d = at_least_one(params.value("d_period").toInt(3));
return compute_stochastic(high, low, close, k, d);
}
if (name == "CCI")
return compute_cci(high, low, close, period);
if (name == "WILLIAMS_R")
return compute_williams_r(high, low, close, period);
if (name == "MFI")
return compute_mfi(high, low, close, vol, period);
if (name == "ROC")
return compute_roc(close, period);
// Trend
if (name == "ADX")
return compute_adx(high, low, close, period);
if (name == "SUPERTREND") {
double mult = params.value("multiplier").toDouble(3.0);
return compute_supertrend(high, low, close, period, mult);
}
if (name == "AROON")
return compute_aroon(high, low, period);
if (name == "ICHIMOKU") {
int tenkan = at_least_one(params.value("tenkan").toInt(9));
int kijun = at_least_one(params.value("kijun").toInt(26));
int senkou = at_least_one(params.value("senkou").toInt(52));
return compute_ichimoku(high, low, tenkan, kijun, senkou);
}
// Volatility
if (name == "ATR")
return compute_atr(high, low, close, period);
if (name == "BOLLINGER") {
double sd = params.value("std_dev").toDouble(2.0);
return compute_bollinger(close, period, sd);
}
if (name == "KELTNER") {
double mult = params.value("multiplier").toDouble(1.5);
return compute_keltner(high, low, close, period, mult);
}
if (name == "DONCHIAN")
return compute_donchian(high, low, period);
// Volume
if (name == "OBV")
return compute_obv(close, vol);
if (name == "CMF")
return compute_cmf(high, low, close, vol, period);
if (name == "VOL_WIN_CHG") {
int window = at_least_one(params.value("window").toInt(10));
return compute_vol_win_chg(vol, window);
}
return make_error(QStringLiteral("Unknown indicator: ") + name);
}
// ── Stock attributes ────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute_stock_attr(const QVector<OhlcvCandle>& candles, const QString& attr) {
const auto& curr = candles.last();
const auto& prev = candles[candles.size() - 2];
IndicatorResult r;
r.valid = true;
double cv = 0, pv = 0;
if (attr == "CLOSE") {
cv = curr.close;
pv = prev.close;
} else if (attr == "OPEN") {
cv = curr.open;
pv = prev.open;
} else if (attr == "HIGH") {
cv = curr.high;
pv = prev.high;
} else if (attr == "LOW") {
cv = curr.low;
pv = prev.low;
} else if (attr == "VOLUME") {
cv = curr.volume;
pv = prev.volume;
} else if (attr == "VWAP") {
// Cumulative VWAP over the provided window: Σ(typical·vol)/Σ(vol).
// (Per-bar (H+L+C)/3 was just typical price, not a VWAP.)
const int n = candles.size();
double num = 0.0, den = 0.0;
for (int i = 0; i < n; ++i) {
if (i == n - 1) // snapshot the previous-bar VWAP before adding the last bar
pv = den > 0.0 ? num / den : prev.close;
const auto& c = candles[i];
const double tp = (c.high + c.low + c.close) / 3.0;
const double v = c.volume > 0.0 ? c.volume : 0.0;
num += tp * v;
den += v;
}
cv = den > 0.0 ? num / den : curr.close;
}
r.current[QStringLiteral("value")] = cv;
r.previous[QStringLiteral("value")] = pv;
return r;
}
// ── Moving Averages ─────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute_sma(const QVector<double>& src, int period) {
auto s = sma_series(src, period);
int n = s.size();
if (n < 2 || std::isnan(s[n - 1]))
return make_error(QStringLiteral("Insufficient data for SMA"));
double prev = (n >= 2 && !std::isnan(s[n - 2])) ? s[n - 2] : s[n - 1];
return make_result(s[n - 1], prev);
}
IndicatorResult IndicatorEngine::compute_ema(const QVector<double>& src, int period) {
auto s = ema_series(src, period);
int n = s.size();
if (n < 2 || std::isnan(s[n - 1]))
return make_error(QStringLiteral("Insufficient data for EMA"));
double prev = (n >= 2 && !std::isnan(s[n - 2])) ? s[n - 2] : s[n - 1];
return make_result(s[n - 1], prev);
}
IndicatorResult IndicatorEngine::compute_wma(const QVector<double>& src, int period) {
int n = src.size();
if (n < period)
return make_error(QStringLiteral("Insufficient data for WMA"));
double denom = period * (period + 1) / 2.0;
auto calc = [&](int end) {
double sum = 0;
for (int i = 0; i < period; ++i)
sum += src[end - period + 1 + i] * (i + 1);
return sum / denom;
};
double curr = calc(n - 1);
double prev = (n >= period + 1) ? calc(n - 2) : curr;
return make_result(curr, prev);
}
IndicatorResult IndicatorEngine::compute_dema(const QVector<double>& src, int period) {
auto e1 = ema_series(src, period);
auto e2 = ema_series(e1, period);
int n = e2.size();
if (n < 1 || std::isnan(e2[n - 1]))
return make_error(QStringLiteral("Insufficient data for DEMA"));
double curr = 2.0 * e1[n - 1] - e2[n - 1];
double prev = curr;
if (n >= 2 && !std::isnan(e2[n - 2]))
prev = 2.0 * e1[n - 2] - e2[n - 2];
return make_result(curr, prev);
}
IndicatorResult IndicatorEngine::compute_tema(const QVector<double>& src, int period) {
auto e1 = ema_series(src, period);
auto e2 = ema_series(e1, period);
auto e3 = ema_series(e2, period);
int n = e3.size();
if (n < 1 || std::isnan(e3[n - 1]))
return make_error(QStringLiteral("Insufficient data for TEMA"));
double curr = 3.0 * e1[n - 1] - 3.0 * e2[n - 1] + e3[n - 1];
double prev = curr;
if (n >= 2 && !std::isnan(e3[n - 2]))
prev = 3.0 * e1[n - 2] - 3.0 * e2[n - 2] + e3[n - 2];
return make_result(curr, prev);
}
// ── Momentum ────────────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute_rsi(const QVector<double>& close, int period) {
int n = close.size();
if (n < period + 1)
return make_error(QStringLiteral("Insufficient data for RSI"));
QVector<double> gains(n, 0), losses(n, 0);
for (int i = 1; i < n; ++i) {
double diff = close[i] - close[i - 1];
if (diff > 0)
gains[i] = diff;
else
losses[i] = -diff;
}
double avg_gain = 0, avg_loss = 0;
for (int i = 1; i <= period; ++i) {
avg_gain += gains[i];
avg_loss += losses[i];
}
avg_gain /= period;
avg_loss /= period;
QVector<double> rsi_vals(n, std::numeric_limits<double>::quiet_NaN());
auto calc_rsi = [](double ag, double al) -> double {
if (al < 1e-10)
return 100.0;
return 100.0 - 100.0 / (1.0 + ag / al);
};
rsi_vals[period] = calc_rsi(avg_gain, avg_loss);
for (int i = period + 1; i < n; ++i) {
avg_gain = (avg_gain * (period - 1) + gains[i]) / period;
avg_loss = (avg_loss * (period - 1) + losses[i]) / period;
rsi_vals[i] = calc_rsi(avg_gain, avg_loss);
}
double prev = (n >= 2 && !std::isnan(rsi_vals[n - 2])) ? rsi_vals[n - 2] : rsi_vals[n - 1];
return make_result(rsi_vals[n - 1], prev);
}
IndicatorResult IndicatorEngine::compute_macd(const QVector<double>& close, int fast, int slow, int signal_period) {
auto ema_fast = ema_series(close, fast);
auto ema_slow = ema_series(close, slow);
int n = close.size();
QVector<double> macd_line(n, std::numeric_limits<double>::quiet_NaN());
for (int i = 0; i < n; ++i) {
if (!std::isnan(ema_fast[i]) && !std::isnan(ema_slow[i]))
macd_line[i] = ema_fast[i] - ema_slow[i];
}
auto signal_line = ema_series(macd_line, signal_period);
if (std::isnan(macd_line[n - 1]) || std::isnan(signal_line[n - 1]))
return make_error(QStringLiteral("Insufficient data for MACD"));
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("line")] = macd_line[n - 1];
r.current[QStringLiteral("signal_line")] = signal_line[n - 1];
r.current[QStringLiteral("histogram")] = macd_line[n - 1] - signal_line[n - 1];
if (n >= 2 && !std::isnan(macd_line[n - 2]) && !std::isnan(signal_line[n - 2])) {
r.previous[QStringLiteral("line")] = macd_line[n - 2];
r.previous[QStringLiteral("signal_line")] = signal_line[n - 2];
r.previous[QStringLiteral("histogram")] = macd_line[n - 2] - signal_line[n - 2];
}
return r;
}
IndicatorResult IndicatorEngine::compute_stochastic(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int k_period, int d_period) {
int n = close.size();
if (n < k_period)
return make_error(QStringLiteral("Insufficient data for Stochastic"));
QVector<double> k_vals(n, std::numeric_limits<double>::quiet_NaN());
for (int i = k_period - 1; i < n; ++i) {
double hh = high[i], ll = low[i];
for (int j = 1; j < k_period; ++j) {
hh = std::max(hh, high[i - j]);
ll = std::min(ll, low[i - j]);
}
double range = hh - ll;
k_vals[i] = range > 1e-10 ? (close[i] - ll) / range * 100.0 : 50.0;
}
auto d_vals = sma_series(k_vals, d_period);
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("k")] = k_vals[n - 1];
r.current[QStringLiteral("d")] = std::isnan(d_vals[n - 1]) ? k_vals[n - 1] : d_vals[n - 1];
if (n >= 2 && !std::isnan(k_vals[n - 2])) {
r.previous[QStringLiteral("k")] = k_vals[n - 2];
r.previous[QStringLiteral("d")] = std::isnan(d_vals[n - 2]) ? k_vals[n - 2] : d_vals[n - 2];
}
return r;
}
IndicatorResult IndicatorEngine::compute_cci(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int period) {
int n = close.size();
if (n < period)
return make_error(QStringLiteral("Insufficient data for CCI"));
QVector<double> tp(n);
for (int i = 0; i < n; ++i)
tp[i] = (high[i] + low[i] + close[i]) / 3.0;
auto sma = sma_series(tp, period);
auto calc_cci = [&](int idx) -> double {
if (std::isnan(sma[idx]))
return 0;
double mean_dev = 0;
for (int j = 0; j < period; ++j)
mean_dev += std::abs(tp[idx - j] - sma[idx]);
mean_dev /= period;
return mean_dev > 1e-10 ? (tp[idx] - sma[idx]) / (0.015 * mean_dev) : 0;
};
double curr = calc_cci(n - 1);
double prev = (n >= period + 1) ? calc_cci(n - 2) : curr;
return make_result(curr, prev);
}
IndicatorResult IndicatorEngine::compute_williams_r(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int period) {
int n = close.size();
if (n < period)
return make_error(QStringLiteral("Insufficient data for Williams %R"));
auto calc = [&](int idx) -> double {
double hh = high[idx], ll = low[idx];
for (int j = 1; j < period; ++j) {
hh = std::max(hh, high[idx - j]);
ll = std::min(ll, low[idx - j]);
}
double range = hh - ll;
return range > 1e-10 ? (hh - close[idx]) / range * -100.0 : -50.0;
};
double curr = calc(n - 1);
double prev = (n >= period + 1) ? calc(n - 2) : curr;
return make_result(curr, prev);
}
IndicatorResult IndicatorEngine::compute_mfi(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, const QVector<double>& volume, int period) {
int n = close.size();
if (n < period + 1)
return make_error(QStringLiteral("Insufficient data for MFI"));
QVector<double> tp(n);
for (int i = 0; i < n; ++i)
tp[i] = (high[i] + low[i] + close[i]) / 3.0;
auto calc = [&](int end) -> double {
double pos = 0, neg = 0;
for (int i = end - period + 1; i <= end; ++i) {
double mf = tp[i] * volume[i];
if (tp[i] > tp[i - 1])
pos += mf;
else if (tp[i] < tp[i - 1])
neg += mf;
}
return neg > 1e-10 ? 100.0 - 100.0 / (1.0 + pos / neg) : 100.0;
};
double curr = calc(n - 1);
double prev = (n >= period + 2) ? calc(n - 2) : curr;
return make_result(curr, prev);
}
IndicatorResult IndicatorEngine::compute_roc(const QVector<double>& close, int period) {
int n = close.size();
if (n <= period)
return make_error(QStringLiteral("Insufficient data for ROC"));
// A zero reference close (an unfilled bar, or a bad tick that reached the
// aggregator) makes this division ±inf. inf is not NaN, so it slips through
// every std::isnan guard downstream and compares true against any threshold —
// enough to fire a live entry. Fail the indicator instead.
const double base = close[n - 1 - period];
if (!std::isfinite(base) || std::abs(base) < 1e-10)
return make_error(QStringLiteral("ROC: zero/invalid reference price"));
double curr = (close[n - 1] - base) / base * 100.0;
double prev = curr;
if (n > period + 1) {
const double prev_base = close[n - 2 - period];
prev = (std::isfinite(prev_base) && std::abs(prev_base) >= 1e-10)
? (close[n - 2] - prev_base) / prev_base * 100.0
: std::numeric_limits<double>::quiet_NaN();
}
return make_result(curr, prev);
}
// ── Trend ───────────────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute_adx(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int period) {
int n = close.size();
if (n < period * 2 + 1)
return make_error(QStringLiteral("Insufficient data for ADX"));
auto tr = true_range_series(high, low, close);
QVector<double> plus_dm(n, 0), minus_dm(n, 0);
for (int i = 1; i < n; ++i) {
double up = high[i] - high[i - 1];
double down = low[i - 1] - low[i];
if (up > down && up > 0)
plus_dm[i] = up;
if (down > up && down > 0)
minus_dm[i] = down;
}
// Wilder's smoothing
double atr_smooth = 0, plus_smooth = 0, minus_smooth = 0;
for (int i = 1; i <= period; ++i) {
atr_smooth += tr[i];
plus_smooth += plus_dm[i];
minus_smooth += minus_dm[i];
}
QVector<double> dx_vals;
auto calc_dx = [&]() -> double {
double pdi = atr_smooth > 1e-10 ? plus_smooth / atr_smooth * 100.0 : 0;
double mdi = atr_smooth > 1e-10 ? minus_smooth / atr_smooth * 100.0 : 0;
double sum = pdi + mdi;
return sum > 1e-10 ? std::abs(pdi - mdi) / sum * 100.0 : 0;
};
dx_vals.append(calc_dx());
for (int i = period + 1; i < n; ++i) {
atr_smooth = atr_smooth - atr_smooth / period + tr[i];
plus_smooth = plus_smooth - plus_smooth / period + plus_dm[i];
minus_smooth = minus_smooth - minus_smooth / period + minus_dm[i];
dx_vals.append(calc_dx());
}
if (dx_vals.size() < period)
return make_error(QStringLiteral("Insufficient data for ADX"));
double adx = 0;
for (int i = 0; i < period; ++i)
adx += dx_vals[i];
adx /= period;
for (int i = period; i < dx_vals.size(); ++i)
adx = (adx * (period - 1) + dx_vals[i]) / period;
double prev_adx = adx;
if (dx_vals.size() > period) {
double adx2 = 0;
for (int i = 0; i < period; ++i)
adx2 += dx_vals[i];
adx2 /= period;
for (int i = period; i < dx_vals.size() - 1; ++i)
adx2 = (adx2 * (period - 1) + dx_vals[i]) / period;
prev_adx = adx2;
}
IndicatorResult r;
r.valid = true;
double pdi_curr = atr_smooth > 1e-10 ? plus_smooth / atr_smooth * 100.0 : 0;
double mdi_curr = atr_smooth > 1e-10 ? minus_smooth / atr_smooth * 100.0 : 0;
r.current[QStringLiteral("value")] = adx;
r.current[QStringLiteral("plus_di")] = pdi_curr;
r.current[QStringLiteral("minus_di")] = mdi_curr;
r.previous[QStringLiteral("value")] = prev_adx;
r.previous[QStringLiteral("plus_di")] = pdi_curr;
r.previous[QStringLiteral("minus_di")] = mdi_curr;
return r;
}
IndicatorResult IndicatorEngine::compute_supertrend(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int period, double multiplier) {
int n = close.size();
auto atr_s = true_range_series(high, low, close);
auto atr_ema = ema_series(atr_s, period);
if (n < period + 1 || std::isnan(atr_ema[n - 1]))
return make_error(QStringLiteral("Insufficient data for SuperTrend"));
QVector<double> upper(n), lower(n), st(n);
QVector<int> dir(n, 1);
int start = period - 1;
for (int i = start; i < n; ++i) {
if (std::isnan(atr_ema[i]))
continue;
double hl2 = (high[i] + low[i]) / 2.0;
upper[i] = hl2 + multiplier * atr_ema[i];
lower[i] = hl2 - multiplier * atr_ema[i];
}
for (int i = start + 1; i < n; ++i) {
if (close[i - 1] > upper[i - 1])
lower[i] = std::max(lower[i], lower[i - 1]);
if (close[i - 1] < lower[i - 1])
upper[i] = std::min(upper[i], upper[i - 1]);
if (close[i] > upper[i])
dir[i] = 1;
else if (close[i] < lower[i])
dir[i] = -1;
else
dir[i] = dir[i - 1];
st[i] = dir[i] == 1 ? lower[i] : upper[i];
}
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("value")] = st[n - 1];
r.current[QStringLiteral("direction")] = dir[n - 1];
if (n >= 2) {
r.previous[QStringLiteral("value")] = st[n - 2];
r.previous[QStringLiteral("direction")] = dir[n - 2];
}
return r;
}
IndicatorResult IndicatorEngine::compute_aroon(const QVector<double>& high, const QVector<double>& low, int period) {
int n = high.size();
if (n < period + 1)
return make_error(QStringLiteral("Insufficient data for Aroon"));
auto calc = [&](int end) -> std::pair<double, double> {
int hi_idx = 0, lo_idx = 0;
double hh = high[end], ll = low[end];
for (int j = 1; j <= period; ++j) {
if (high[end - j] > hh) {
hh = high[end - j];
hi_idx = j;
}
if (low[end - j] < ll) {
ll = low[end - j];
lo_idx = j;
}
}
double up = (static_cast<double>(period - hi_idx) / period) * 100.0;
double down = (static_cast<double>(period - lo_idx) / period) * 100.0;
return {up, down};
};
auto [up_c, dn_c] = calc(n - 1);
auto [up_p, dn_p] = (n >= period + 2) ? calc(n - 2) : std::pair{up_c, dn_c};
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("up")] = up_c;
r.current[QStringLiteral("down")] = dn_c;
r.previous[QStringLiteral("up")] = up_p;
r.previous[QStringLiteral("down")] = dn_p;
return r;
}
IndicatorResult IndicatorEngine::compute_ichimoku(const QVector<double>& high, const QVector<double>& low, int tenkan,
int kijun, int senkou) {
int n = high.size();
if (n < senkou)
return make_error(QStringLiteral("Insufficient data for Ichimoku"));
auto midpoint = [&](int end, int period) -> double {
double hh = high[end], ll = low[end];
for (int j = 1; j < period; ++j) {
hh = std::max(hh, high[end - j]);
ll = std::min(ll, low[end - j]);
}
return (hh + ll) / 2.0;
};
int i = n - 1;
double ts = midpoint(i, tenkan);
double ks = midpoint(i, kijun);
double sa = (ts + ks) / 2.0;
double sb = midpoint(i, senkou);
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("tenkan_sen")] = ts;
r.current[QStringLiteral("kijun_sen")] = ks;
r.current[QStringLiteral("senkou_a")] = sa;
r.current[QStringLiteral("senkou_b")] = sb;
if (n > senkou) {
int p = n - 2;
r.previous[QStringLiteral("tenkan_sen")] = midpoint(p, tenkan);
r.previous[QStringLiteral("kijun_sen")] = midpoint(p, kijun);
double pts = midpoint(p, tenkan), pks = midpoint(p, kijun);
r.previous[QStringLiteral("senkou_a")] = (pts + pks) / 2.0;
r.previous[QStringLiteral("senkou_b")] = midpoint(p, senkou);
}
return r;
}
// ── Volatility ──────────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute_atr(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int period) {
auto tr = true_range_series(high, low, close);
int n = tr.size();
if (n < period + 1)
return make_error(QStringLiteral("Insufficient data for ATR"));
double atr = 0;
for (int i = 0; i < period; ++i)
atr += tr[i + 1];
atr /= period;
for (int i = period + 1; i < n; ++i)
atr = (atr * (period - 1) + tr[i]) / period;
double prev_atr = atr;
if (n > period + 1) {
double a2 = 0;
for (int i = 0; i < period; ++i)
a2 += tr[i + 1];
a2 /= period;
for (int i = period + 1; i < n - 1; ++i)
a2 = (a2 * (period - 1) + tr[i]) / period;
prev_atr = a2;
}
return make_result(atr, prev_atr);
}
IndicatorResult IndicatorEngine::compute_bollinger(const QVector<double>& close, int period, double std_dev_mult) {
int n = close.size();
if (n < period)
return make_error(QStringLiteral("Insufficient data for Bollinger"));
auto sma = sma_series(close, period);
auto calc = [&](int idx) -> std::tuple<double, double, double, double, double> {
double mid = sma[idx];
double sum_sq = 0;
for (int j = 0; j < period; ++j) {
double diff = close[idx - j] - mid;
sum_sq += diff * diff;
}
double sd = std::sqrt(sum_sq / period);
double upper = mid + std_dev_mult * sd;
double lower = mid - std_dev_mult * sd;
double width = mid > 1e-10 ? (upper - lower) / mid : 0;
double pct_b = (upper - lower) > 1e-10 ? (close[idx] - lower) / (upper - lower) : 0.5;
return {upper, mid, lower, width, pct_b};
};
auto [u, m, l, w, pb] = calc(n - 1);
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("upper")] = u;
r.current[QStringLiteral("middle")] = m;
r.current[QStringLiteral("lower")] = l;
r.current[QStringLiteral("width")] = w;
r.current[QStringLiteral("pct_b")] = pb;
if (n >= period + 1) {
auto [u2, m2, l2, w2, pb2] = calc(n - 2);
r.previous[QStringLiteral("upper")] = u2;
r.previous[QStringLiteral("middle")] = m2;
r.previous[QStringLiteral("lower")] = l2;
r.previous[QStringLiteral("width")] = w2;
r.previous[QStringLiteral("pct_b")] = pb2;
}
return r;
}
IndicatorResult IndicatorEngine::compute_keltner(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, int period, double multiplier) {
auto ema = ema_series(close, period);
auto tr = true_range_series(high, low, close);
auto atr = ema_series(tr, period);
int n = close.size();
if (n < 1 || std::isnan(ema[n - 1]) || std::isnan(atr[n - 1]))
return make_error(QStringLiteral("Insufficient data for Keltner"));
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("upper")] = ema[n - 1] + multiplier * atr[n - 1];
r.current[QStringLiteral("middle")] = ema[n - 1];
r.current[QStringLiteral("lower")] = ema[n - 1] - multiplier * atr[n - 1];
if (n >= 2 && !std::isnan(ema[n - 2]) && !std::isnan(atr[n - 2])) {
r.previous[QStringLiteral("upper")] = ema[n - 2] + multiplier * atr[n - 2];
r.previous[QStringLiteral("middle")] = ema[n - 2];
r.previous[QStringLiteral("lower")] = ema[n - 2] - multiplier * atr[n - 2];
}
return r;
}
IndicatorResult IndicatorEngine::compute_donchian(const QVector<double>& high, const QVector<double>& low, int period) {
int n = high.size();
if (n < period)
return make_error(QStringLiteral("Insufficient data for Donchian"));
auto calc = [&](int end) -> std::pair<double, double> {
double hh = high[end], ll = low[end];
for (int j = 1; j < period; ++j) {
hh = std::max(hh, high[end - j]);
ll = std::min(ll, low[end - j]);
}
return {hh, ll};
};
auto [uc, lc] = calc(n - 1);
IndicatorResult r;
r.valid = true;
r.current[QStringLiteral("upper")] = uc;
r.current[QStringLiteral("lower")] = lc;
if (n >= period + 1) {
auto [up, lp] = calc(n - 2);
r.previous[QStringLiteral("upper")] = up;
r.previous[QStringLiteral("lower")] = lp;
}
return r;
}
// ── Volume ──────────────────────────────────────────────────────────────────
IndicatorResult IndicatorEngine::compute_obv(const QVector<double>& close, const QVector<double>& volume) {
int n = close.size();
if (n < 2)
return make_error(QStringLiteral("Insufficient data for OBV"));
double obv = 0, prev_obv = 0;
for (int i = 1; i < n; ++i) {
if (i == n - 1)
prev_obv = obv;
if (close[i] > close[i - 1])
obv += volume[i];
else if (close[i] < close[i - 1])
obv -= volume[i];
}
return make_result(obv, prev_obv);
}
IndicatorResult IndicatorEngine::compute_vol_win_chg(const QVector<double>& volume, int window) {
if (window < 1)
return make_error(QStringLiteral("VOL_WIN_CHG: window must be >= 1"));
const int n = volume.size();
if (n < 2 * window)
return make_error(QStringLiteral("Insufficient data for VOL_WIN_CHG (need %1 bars)").arg(2 * window));
// Compute the windowed %-change at the current bar and at the previous bar so
// crossing/rising operators (which re-read the prior sample) stay consistent.
auto win_pct = [&](int last_index) -> double {
double sum_last = 0, sum_prev = 0;
for (int i = last_index - window + 1; i <= last_index; ++i)
sum_last += volume[i];
for (int i = last_index - 2 * window + 1; i <= last_index - window; ++i)
sum_prev += volume[i];
if (sum_prev <= 0.0)
return std::numeric_limits<double>::quiet_NaN();
return (sum_last / sum_prev - 1.0) * 100.0;
};
double curr = win_pct(n - 1);
double prev = (n >= 2 * window + 1) ? win_pct(n - 2) : std::numeric_limits<double>::quiet_NaN();
return make_result(curr, prev);
}
IndicatorResult IndicatorEngine::compute_cmf(const QVector<double>& high, const QVector<double>& low,
const QVector<double>& close, const QVector<double>& volume, int period) {
int n = close.size();
if (n < period)
return make_error(QStringLiteral("Insufficient data for CMF"));
auto calc = [&](int end) -> double {
double mfv_sum = 0, vol_sum = 0;
for (int j = 0; j < period; ++j) {
int idx = end - j;
double hl = high[idx] - low[idx];
double mf_mult = hl > 1e-10 ? ((close[idx] - low[idx]) - (high[idx] - close[idx])) / hl : 0;
mfv_sum += mf_mult * volume[idx];
vol_sum += volume[idx];
}
return vol_sum > 1e-10 ? mfv_sum / vol_sum : 0;
};
double curr = calc(n - 1);
double prev = (n >= period + 1) ? calc(n - 2) : curr;
return make_result(curr, prev);
}
} // namespace fincept::algo