react-native-vroom-chart 0.1.0

package/cpp/_core_src/ma_overlay.h

@@ -0,0 +1,42 @@
+// Moving-average overlay line — a single SMA/EMA polyline drawn on the price
+// pane (over the candles, on the candle price scale). One call per overlay line.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+class SkCanvas;
+
+namespace vroom {
+struct Layout;
+struct PriceBounds;
+}  // namespace vroom
+
+namespace vroom::ma_overlay {
+
+// Draws `values_visible` (aligned with `visible`, NaN where undefined) as a
+// polyline on the price pane using candle_center_x + price_to_y. `color` is
+// 0xAARRGGBB; `width` is the stroke px. Clipped to the candle area.
+//
+// `break_before` (optional, aligned with `visible`) forces a new subpath at any
+// index where it is non-zero — used by VWAP to break the line at session
+// resets. Pass nullptr for continuous lines (SMA/EMA).
+void draw(SkCanvas* canvas,
+          const Layout& lay,
+          const PriceBounds& bounds,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* values_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float candle_area_h,
+          uint32_t color,
+          float width,
+          const unsigned char* break_before = nullptr);
+
+}  // namespace vroom::ma_overlay

package/cpp/_core_src/macd.cpp

@@ -0,0 +1,68 @@
+#include "macd.h"
+
+#include <cmath>  // std::nan, std::isfinite
+
+namespace vroom::macd {
+
+namespace {
+// SMA-seeded EMA over `src` (which may have a leading NaN run). Fills `out`
+// (resized to src.size()): NaN until the seed index, the seed = SMA of the
+// first `period` finite values, then ema = alpha*src + (1-alpha)*prev.
+void ema_seeded(const std::vector<double>& src, int period,
+                std::vector<double>& out) {
+    const std::size_t n = src.size();
+    out.assign(n, std::nan(""));
+    if (period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+
+    std::size_t f = 0;
+    while (f < n && !std::isfinite(src[f])) ++f;
+    if (f >= n || f + P > n) return;  // not enough finite values to seed
+
+    const std::size_t seed = f + P - 1;
+    double sum = 0.0;
+    for (std::size_t k = f; k <= seed; ++k) sum += src[k];
+    double prev = sum / static_cast<double>(P);
+    out[seed] = prev;
+
+    const double alpha = 2.0 / (static_cast<double>(P) + 1.0);
+    for (std::size_t i = seed + 1; i < n; ++i) {
+        if (!std::isfinite(src[i])) break;  // series are contiguous after f
+        prev = alpha * src[i] + (1.0 - alpha) * prev;
+        out[i] = prev;
+    }
+}
+}  // namespace
+
+void compute(const ::VroomCandle* candles, std::size_t n, int fast, int slow,
+             int signal, std::vector<double>& macd_out,
+             std::vector<double>& signal_out, std::vector<double>& hist_out) {
+    macd_out.assign(n, std::nan(""));
+    signal_out.assign(n, std::nan(""));
+    hist_out.assign(n, std::nan(""));
+    if (!candles || fast < 1 || slow < 1 || signal < 1) return;
+
+    std::vector<double> closes(n);
+    for (std::size_t i = 0; i < n; ++i) closes[i] = candles[i].close;
+
+    std::vector<double> ema_fast;
+    std::vector<double> ema_slow;
+    ema_seeded(closes, fast, ema_fast);
+    ema_seeded(closes, slow, ema_slow);
+
+    for (std::size_t i = 0; i < n; ++i) {
+        if (std::isfinite(ema_fast[i]) && std::isfinite(ema_slow[i])) {
+            macd_out[i] = ema_fast[i] - ema_slow[i];
+        }
+    }
+
+    ema_seeded(macd_out, signal, signal_out);
+
+    for (std::size_t i = 0; i < n; ++i) {
+        if (std::isfinite(macd_out[i]) && std::isfinite(signal_out[i])) {
+            hist_out[i] = macd_out[i] - signal_out[i];
+        }
+    }
+}
+
+}  // namespace vroom::macd

package/cpp/_core_src/macd.h

@@ -0,0 +1,29 @@
+// MACD — pure computation, no Skia. Kept Skia-free so it builds into the
+// unit-test target. Mirrors rsi.cpp's NaN-warmup convention.
+//
+// MACD line   = EMA(fast) - EMA(slow) of close
+// Signal line = EMA(signal) of the MACD line
+// Histogram   = MACD - Signal
+// EMAs are SMA-seeded: NaN until the first `period` values exist (the seed is
+// their simple average), then ema = alpha*src + (1-alpha)*prev, alpha=2/(p+1).
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::macd {
+
+// Computes MACD over the closes of [candles, candles+n). fast/slow/signal are
+// clamped to >= 1 (callers pass 12/26/9 by default; slow should exceed fast).
+// Fills three series (each resized to n, NaN where undefined):
+//   macd_out   — EMA(fast) - EMA(slow), defined from index slow-1
+//   signal_out — EMA(signal) of macd_out, defined from (slow-1)+(signal-1)
+//   hist_out   — macd_out - signal_out, defined where both are
+void compute(const ::VroomCandle* candles, std::size_t n, int fast, int slow,
+             int signal, std::vector<double>& macd_out,
+             std::vector<double>& signal_out, std::vector<double>& hist_out);
+
+}  // namespace vroom::macd

package/cpp/_core_src/macd_pane.cpp

@@ -0,0 +1,199 @@
+#include "macd_pane.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypeface.h"
+#pragma clang diagnostic pop
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+#include "chart.h"
+#include "fonts.h"
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::macd_pane {
+
+namespace {
+constexpr SkColor kMacdLine = 0xff2962ff;    // blue MACD line
+constexpr SkColor kSignalLine = 0xffff6d00;  // orange signal line
+constexpr SkColor kZeroLine = 0xff484f58;    // zero reference
+constexpr SkColor kDivider = 0xff21262d;     // pane separator
+constexpr float kPadFrac = 0.85f;            // keep curves off the band edges
+}  // namespace
+
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* macd_visible,
+          const double* signal_visible,
+          const double* hist_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom) {
+    if (!canvas || n == 0 || candle_right <= 0.f) return;
+    const float band_h = pane_bottom - pane_top;
+    if (band_h <= 0.f) return;
+
+    const float mid = (pane_top + pane_bottom) * 0.5f;
+    const float half = band_h * 0.5f * kPadFrac;
+
+    // Auto-scale symmetric about zero across all visible finite values.
+    double scale = 0.0;
+    auto track = [&](const double* s) {
+        if (!s) return;
+        for (std::size_t i = 0; i < n; ++i) {
+            if (std::isfinite(s[i])) scale = std::max(scale, std::abs(s[i]));
+        }
+    };
+    track(macd_visible);
+    track(signal_visible);
+    track(hist_visible);
+
+    auto y_for = [&](double v) -> float {
+        if (scale <= 0.0) return mid;
+        return mid - static_cast<float>(v / scale) * half;
+    };
+
+    // Mask the band (candles can overflow below the shortened price pane).
+    SkPaint bg;
+    bg.setColor(chart.theme.colors[VROOM_COLOR_BACKGROUND]);
+    canvas->drawRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom),
+                     bg);
+
+    // Pane separator (top edge).
+    SkPaint divider;
+    divider.setColor(kDivider);
+    divider.setStrokeWidth(1.f);
+    canvas->drawLine(0.f, pane_top, candle_right, pane_top, divider);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom));
+
+    // Zero line.
+    SkPaint zero;
+    zero.setAntiAlias(true);
+    zero.setColor(kZeroLine);
+    zero.setStrokeWidth(1.f);
+    canvas->drawLine(0.f, mid, candle_right, mid, zero);
+
+    // Histogram bars: from the zero line to y_for(hist), 4-color (green above /
+    // red below, full alpha when accelerating, half when decelerating).
+    if (hist_visible) {
+        const float body_w =
+            vroom::candle_body_width(lay, window_ms, candle_duration_ms);
+        const float half_body = body_w * 0.5f;
+        const float zero_y = y_for(0.0);
+        const SkColor bull = chart.theme.colors[VROOM_COLOR_BULL];
+        const SkColor bear = chart.theme.colors[VROOM_COLOR_BEAR];
+        for (std::size_t i = 0; i < n; ++i) {
+            const double h = hist_visible[i];
+            if (!std::isfinite(h)) continue;
+            const bool have_prev = i > 0 && std::isfinite(hist_visible[i - 1]);
+            const double prev = have_prev ? hist_visible[i - 1] : h;
+            bool accelerating = true;
+            if (have_prev) {
+                accelerating = h >= 0.0 ? h >= prev : h <= prev;
+            }
+            SkPaint bar;
+            bar.setAntiAlias(true);
+            bar.setColor(h >= 0.0 ? bull : bear);
+            bar.setAlphaf(accelerating ? 1.0f : 0.5f);
+            const float cx = vroom::candle_center_x(
+                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
+                window_ms);
+            const float vy = y_for(h);
+            const float top = std::min(zero_y, vy);
+            const float bot = std::max(zero_y, vy);
+            canvas->drawRect(
+                SkRect::MakeLTRB(cx - half_body, top, cx + half_body, bot), bar);
+        }
+    }
+
+    // MACD + signal lines.
+    auto stroke_series = [&](const double* series, SkColor color) {
+        if (!series) return;
+        SkPathBuilder path;
+        bool pen_down = false;
+        for (std::size_t i = 0; i < n; ++i) {
+            const double v = series[i];
+            if (!std::isfinite(v)) {
+                pen_down = false;
+                continue;
+            }
+            const float x = vroom::candle_center_x(
+                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
+                window_ms);
+            const float y = y_for(v);
+            if (pen_down) {
+                path.lineTo(x, y);
+            } else {
+                path.moveTo(x, y);
+                pen_down = true;
+            }
+        }
+        SkPaint line;
+        line.setAntiAlias(true);
+        line.setColor(color);
+        line.setStyle(SkPaint::kStroke_Style);
+        line.setStrokeWidth(1.5f);
+        canvas->drawPath(path.detach(), line);
+    };
+    stroke_series(signal_visible, kSignalLine);
+    stroke_series(macd_visible, kMacdLine);  // MACD over signal
+
+    // Caption, top-left of the pane.
+    auto tf = vroom::axis_typeface();
+    if (tf) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        char caption[40];
+        std::snprintf(caption, sizeof(caption), "MACD %d %d %d", chart.macd_fast,
+                      chart.macd_slow, chart.macd_signal);
+        SkRect cb;
+        font.measureText(caption, std::strlen(caption), SkTextEncoding::kUTF8,
+                         &cb);
+        SkPaint cap_paint;
+        cap_paint.setAntiAlias(true);
+        cap_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        canvas->drawString(caption, 6.f, pane_top + 4.f - cb.fTop, font,
+                           cap_paint);
+    }
+    canvas->restore();
+
+    // "0" label in the y-axis strip at the zero line.
+    if (tf) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        SkPaint text_paint;
+        text_paint.setAntiAlias(true);
+        text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        SkRect tb;
+        const float tw =
+            font.measureText("0", 1, SkTextEncoding::kUTF8, &tb);
+        const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+        const float text_x = axis_center_x - tw * 0.5f;
+        const float baseline_y = mid - (tb.fTop + tb.fBottom) * 0.5f;
+        canvas->drawString("0", text_x, baseline_y, font, text_paint);
+    }
+}
+
+}  // namespace vroom::macd_pane

package/cpp/_core_src/macd_pane.h

@@ -0,0 +1,41 @@
+// MACD indicator pane — histogram bars, MACD + signal lines, and a zero line,
+// drawn in a band below the candles. Its own module alongside rsi_pane so the
+// chart orchestrator stays thin.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+class SkCanvas;
+
+namespace vroom {
+struct Layout;
+}  // namespace vroom
+
+struct VroomChart;
+
+namespace vroom::macd_pane {
+
+// Draws the MACD pane spanning [pane_top, pane_bottom]. The macd/signal/hist
+// series are aligned with `visible` (NaN where undefined). The vertical scale
+// auto-fits the visible values symmetrically about zero; shares the candles'
+// horizontal mapping (candle_center_x) so it scrolls in lock-step.
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* macd_visible,
+          const double* signal_visible,
+          const double* hist_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom);
+
+}  // namespace vroom::macd_pane

package/cpp/_core_src/price_indicator.cpp

@@ -0,0 +1,106 @@
+#include "price_indicator.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkRRect.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypeface.h"
+#include "include/effects/SkDashPathEffect.h"
+#pragma clang diagnostic pop
+
+#include <cstdio>
+#include <cstring>
+
+#include "chart.h"
+#include "fonts.h"
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::price_indicator {
+
+namespace {
+constexpr SkScalar kDash[2] = {2.f, 2.f};
+constexpr float kPadV = 4.f;     // box padding above/below the text
+constexpr float kPadH = 8.f;     // box padding left/right of the text
+constexpr float kCorner = 6.f;   // rounded-box corner radius
+}  // namespace
+
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const PriceBounds& bounds,
+          float candle_right,
+          float candle_area_h) {
+    if (!canvas || chart.candles.empty()) return;
+
+    // The "current price" is the latest period's close, regardless of whether
+    // that candle is horizontally in view.
+    const ::VroomCandle& last = chart.candles.back();
+    const bool bull = last.close >= last.open;
+    const SkColor color =
+        chart.theme.colors[bull ? VROOM_COLOR_BULL : VROOM_COLOR_BEAR];
+
+    const float y = vroom::price_to_y(lay, bounds, last.close);
+    if (y < 0.f || y > candle_area_h) return;  // price scrolled off-range
+
+    // Dotted line from the left edge to the y-axis separator.
+    SkPaint line;
+    line.setAntiAlias(true);
+    line.setColor(color);
+    line.setStrokeWidth(1.f);
+    line.setPathEffect(SkDashPathEffect::Make(kDash, 0.f));
+    canvas->drawLine(0.f, y, candle_right, y, line);
+
+    // Price box in the y-axis strip. Needs the axis typeface; if it isn't
+    // loaded yet, the line alone still conveys the level.
+    auto tf = vroom::axis_typeface();
+    if (!tf) return;
+
+    SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    font.setSubpixel(true);
+    font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
+    char buf[32];
+    std::snprintf(buf, sizeof(buf), "%.2f", last.close);
+    const size_t len = std::strlen(buf);
+
+    // Measure the tight glyph bounds (origin at the baseline) so we can center
+    // the actual rendered digits on `y` — robust to fonts whose cap-height
+    // metric doesn't match the digit extent.
+    SkRect tb;
+    const float text_w = font.measureText(buf, len, SkTextEncoding::kUTF8, &tb);
+    const float glyph_h = tb.height();
+
+    // Box wraps the digits (width follows the text), centered on the y-axis
+    // container's center so its text shares the same column as the y-axis
+    // labels, and vertically centered on the price y.
+    const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+    const float box_h = glyph_h + 2.f * kPadV;
+    const float box_w = text_w + 2.f * kPadH;
+    const float box_left = axis_center_x - box_w * 0.5f;
+    const float top = y - box_h * 0.5f;
+    const SkRect rect =
+        SkRect::MakeLTRB(box_left, top, box_left + box_w, top + box_h);
+
+    SkPaint box;
+    box.setAntiAlias(true);
+    box.setColor(color);
+    canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
+
+    // White price text, horizontally centered on the same axis center, and
+    // vertically centered: shift the baseline so the glyph bounds' midpoint
+    // lands on `y` (= the box center and the dotted line).
+    SkPaint text_paint;
+    text_paint.setAntiAlias(true);
+    text_paint.setColor(SK_ColorWHITE);
+    const float text_x = axis_center_x - text_w * 0.5f;
+    const float baseline_y = y - (tb.fTop + tb.fBottom) * 0.5f;
+    canvas->drawString(buf, text_x, baseline_y, font, text_paint);
+}
+
+}  // namespace vroom::price_indicator

package/cpp/_core_src/price_indicator.h

@@ -0,0 +1,29 @@
+// Current-price indicator — a dotted horizontal line at the latest candle's
+// close, spanning the candle area and ending in a rounded price tag in the
+// y-axis strip. Red/green by whether the latest period closed up or down. Kept
+// in its own module alongside candles / labels / crosshair so the chart
+// orchestrator stays thin.
+
+#pragma once
+
+class SkCanvas;
+struct VroomChart;
+
+namespace vroom {
+struct Layout;
+struct PriceBounds;
+}  // namespace vroom
+
+namespace vroom::price_indicator {
+
+// Draws the line across [0, candle_right] at the latest close's y, plus the
+// price box in the y-axis strip. `candle_area_h` is the y of the x-axis
+// separator; the indicator is skipped if the close maps outside [0, candle_area_h].
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const PriceBounds& bounds,
+          float candle_right,
+          float candle_area_h);
+
+}  // namespace vroom::price_indicator

package/cpp/_core_src/rsi.cpp

@@ -0,0 +1,70 @@
+#include "rsi.h"
+
+#include <cmath>  // std::nan, std::isfinite
+
+namespace vroom::rsi {
+
+namespace {
+// Standard rule: avgLoss == 0 → 100 (no downside). When avgGain == 0 and
+// avgLoss > 0, RS = 0 → RSI = 0 falls out naturally.
+double rsi_from(double avg_gain, double avg_loss) {
+    if (avg_loss == 0.0) return 100.0;
+    const double rs = avg_gain / avg_loss;
+    return 100.0 - 100.0 / (1.0 + rs);
+}
+}  // namespace
+
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             std::vector<double>& out) {
+    out.assign(n, std::nan(""));
+    if (!candles || period < 2) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n <= P) return;  // need `period` deltas to seed; first value at index P
+
+    // Seed: simple average of the first P gains/losses (deltas 1..P).
+    double avg_gain = 0.0;
+    double avg_loss = 0.0;
+    for (std::size_t i = 1; i <= P; ++i) {
+        const double d = candles[i].close - candles[i - 1].close;
+        if (d >= 0.0) avg_gain += d;
+        else avg_loss += -d;
+    }
+    avg_gain /= static_cast<double>(P);
+    avg_loss /= static_cast<double>(P);
+    out[P] = rsi_from(avg_gain, avg_loss);
+
+    // Wilder smoothing for the remaining candles.
+    const double pm1 = static_cast<double>(P - 1);
+    const double pd = static_cast<double>(P);
+    for (std::size_t i = P + 1; i < n; ++i) {
+        const double d = candles[i].close - candles[i - 1].close;
+        const double gain = d > 0.0 ? d : 0.0;
+        const double loss = d < 0.0 ? -d : 0.0;
+        avg_gain = (avg_gain * pm1 + gain) / pd;
+        avg_loss = (avg_loss * pm1 + loss) / pd;
+        out[i] = rsi_from(avg_gain, avg_loss);
+    }
+}
+
+void compute_ma(const std::vector<double>& rsi, int ma_period,
+                std::vector<double>& out) {
+    const std::size_t n = rsi.size();
+    out.assign(n, std::nan(""));
+    if (ma_period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(ma_period);
+    if (n < P) return;
+    for (std::size_t i = P - 1; i < n; ++i) {
+        double sum = 0.0;
+        bool ok = true;
+        for (std::size_t k = i + 1 - P; k <= i; ++k) {
+            if (!std::isfinite(rsi[k])) {
+                ok = false;
+                break;
+            }
+            sum += rsi[k];
+        }
+        if (ok) out[i] = sum / static_cast<double>(P);
+    }
+}
+
+}  // namespace vroom::rsi

package/cpp/_core_src/rsi.h

@@ -0,0 +1,32 @@
+// Wilder's RSI — pure computation, no Skia. Kept Skia-free so it builds into
+// the unit-test target.
+//
+// RSI = 100 - 100/(1+RS), RS = avgGain/avgLoss over `period` close-to-close
+// changes. Seed = simple average of the first `period` gains/losses; subsequent
+// values use Wilder smoothing avg = (prevAvg*(period-1) + current)/period.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::rsi {
+
+// Computes RSI over the closes of [candles, candles+n). `period` is clamped to
+// >= 2. Fills `out` (resized to n): out[i] is RSI in [0,100] at candle i, or
+// NaN for i < period and for every index when n <= period (insufficient data).
+// The first defined value is at index == period (the (period+1)-th candle).
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             std::vector<double>& out);
+
+// Simple moving average of an RSI series (the "RSI-based MA" / trendline that
+// most RSI indicators overlay; crossovers of RSI vs. this line are the common
+// signal). `ma_period` is clamped to >= 1. Fills `out` (resized to rsi.size()):
+// out[i] is the mean of rsi[i-ma_period+1 .. i] when all those are finite, else
+// NaN (so it's only defined once `ma_period` valid RSI values exist).
+void compute_ma(const std::vector<double>& rsi, int ma_period,
+                std::vector<double>& out);
+
+}  // namespace vroom::rsi