plotter/tests/test_measure.cpp

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 Martino Ferrari

#include "harness.hpp"
#include <plot/plot/measure.hpp>
#include <plot/plot/plot.hpp>
#include <plot/data/array_series.hpp>
#include <plot/data/detail/cover_count.hpp>
#include <algorithm>
#include <atomic>
#include <cmath>
#include <vector>

PLOT_TEST(measurement_over_interval_matches_direct_computation) {
  std::vector<f32> y; for (int i = 0; i < 1000; ++i) y.push_back(f32(std::sin(static_cast<double>(i) * 0.01)));
  plot::data::ArraySeries s(std::move(y), 0.0, 1.0);
  const auto m = plot::Measure::evaluate(s, 100, 800);
  double sum = 0, sumsq = 0, integral = 0; float lo = 1e30f, hi = -1e30f;
  for (u64 i = 100; i < 800; ++i) {
    const double v = std::sin(static_cast<double>(i) * 0.01);
    sum += v; sumsq += v * v; integral += v;         // dx == 1
    lo = std::min(lo, float(v)); hi = std::max(hi, float(v));
  }
  const double n = 700;
  PLOT_CHECK_NEAR(m.mean, sum / n, 1e-5);
  PLOT_CHECK_NEAR(m.rms, std::sqrt(sumsq / n), 1e-5);
  PLOT_CHECK_NEAR(m.integral, integral, 1e-3);
  PLOT_CHECK_NEAR(m.ymin, lo, 1e-6);
  PLOT_CHECK_NEAR(m.ymax, hi, 1e-6);
  PLOT_CHECK_NEAR(m.dx, 699.0, 1e-9);
}
PLOT_TEST(measurement_uses_pyramid_not_scan) {
  // Guard against a future regression that linear-scans the series, counted rather
  // than timed: a query's cost is the pyramid's covering decomposition -- at most
  // two entries per level -- so the entry count must depend on the *interval* and
  // never on the series length. The wall-clock bound this replaced (1000 evals in
  // < 50 ms) failed on a loaded machine and passed vacuously on a fast one, while
  // saying nothing about the shape of the work.
  std::vector<f32> big(1u << 22, 1.0f);            // 4M samples
  plot::data::ArraySeries s_big(std::move(big), 0.0, 1.0);
  std::vector<f32> small(1u << 13, 1.0f);          // 8k samples: 512x shorter
  plot::data::ArraySeries s_small(std::move(small), 0.0, 1.0);

  auto covers = [](const plot::data::Series& s, u64 begin, u64 end) {
    plot::data::detail::cover_entry_count().store(0, std::memory_order_relaxed);
    (void)plot::Measure::evaluate(s, begin, end);
    return plot::data::detail::cover_entry_count().load(std::memory_order_relaxed);
  };

  // The same absolute interval over both series walks the same run of level-0
  // buckets, so it must fold the same entries: a decomposition that degenerated
  // with series length -- one bucket at a time, or a scan -- shows up here.
  const u64 big_covers = covers(s_big, 1024, 7000);
  PLOT_CHECK(big_covers == covers(s_small, 1024, 7000));
  PLOT_CHECK(big_covers > 0u);                     // the interior came from the pyramid
  PLOT_CHECK(big_covers <= 32u);                   // ~2 entries per level, few levels here

  // A 1-sample interval needs no whole bucket at all: its answer is the two partial
  // edge buckets a pyramid of complete buckets cannot cover (at most 2 * kBucket raw
  // samples through copy_raw), so it folds nothing whatever the series holds.
  PLOT_CHECK(covers(s_big, 1'000'000, 1'000'001) == 0u);
}
PLOT_TEST(empty_and_single_sample_intervals_are_valid_false) {
  std::vector<f32> y{3.0f};
  plot::data::ArraySeries s(std::move(y), 0.0, 1.0);
  PLOT_CHECK(!plot::Measure::evaluate(s, 0, 0).valid);
  PLOT_CHECK(!plot::Measure::evaluate(s, 1, 1).valid);
}

PLOT_TEST(a_measure_over_a_ruler_reports_invalid) {
  // R8: a measurement is read from two *x* coordinates, and a horizontal ruler has
  // no x -- it is the dead field of its orientation. Evaluating the pair anyway
  // silently measured from x=0; now the id `add_measure` returns is real but
  // reports an invalid measurement, and names no band to shade either.
  plot::Plot p;
  p.set_viewport({0.0f, 0.0f, 800.0f, 400.0f});
  p.add_x_axis({"t", {0.0, 100.0}, false, plot::AxisPlace::Bottom, false});
  p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
  std::vector<f32> ys(100);
  for (u64 i = 0; i < 100u; ++i) ys[static_cast<std::size_t>(i)] = f32(i) * 0.01f;
  plot::data::ArraySeries series(std::move(ys), 0.0, 1.0);
  p.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, 0u, 0u});

  const u32 ra = p.add_h_ruler(0.5, plot::Color::hex(0xFFE080));
  const u32 rb = p.add_h_ruler(-0.5, plot::Color::hex(0xFFE080));
  const u32 rulers = p.add_measure(ra, rb);
  PLOT_CHECK(!p.measurement(rulers).valid);
  PLOT_CHECK(!p.measure_span(rulers).valid);  // and no band between dead x's to shade

  // A ruler paired with a real marker is refused for the same reason: one half of
  // the pair has no x to measure from.
  const u32 ca = p.add_cursor(10.0, plot::Color::hex(0xFFFFFF));
  const u32 mixed = p.add_measure(ca, ra);
  PLOT_CHECK(!p.measurement(mixed).valid);
  PLOT_CHECK(!p.measure_span(mixed).valid);

  // Sanity: a marker pair over the same series still measures. The extremes are
  // the stored f32 samples' values, so the expectation is derived from the same
  // arithmetic the store used, not from the decimal literals.
  const u32 cb = p.add_cursor(20.0, plot::Color::hex(0xFFFFFF));
  const u32 markers = p.add_measure(ca, cb);
  const plot::Measurement& m = p.measurement(markers);
  PLOT_CHECK(m.valid);
  PLOT_CHECK_NEAR(m.ymin, static_cast<f64>(f32(10) * 0.01f), 1e-12);
  PLOT_CHECK_NEAR(m.ymax, static_cast<f64>(f32(20) * 0.01f), 1e-12);
}