Home /Modules/utf-4088/voltage_field.cpp

voltage_field.cpp

utf-4088/voltage_field.cpp · 79 line(s) · c

#include "voltage_field.hpp"

#include <algorithm>
#include <cmath>
#include <limits>

namespace utf4088 {
namespace {
bool finite_sample(const VoltageSample& p) {
    return std::isfinite(p.x) && std::isfinite(p.y) &&
           std::isfinite(p.volts) && std::isfinite(p.time);
}
}

FieldState analyze_field(const std::vector<VoltageSample>& samples, std::size_t i) {
    FieldState s{};
    if (samples.empty() || i >= samples.size() || !finite_sample(samples[i])) return s;

    const auto& c = samples[i];
    s.voltage = c.volts;
    const VoltageSample* l = nullptr; const VoltageSample* r = nullptr;
    const VoltageSample* d = nullptr; const VoltageSample* u = nullptr;
    double ld = std::numeric_limits<double>::infinity(), rd = ld, dd = ld, ud = ld;

    for (const auto& p : samples) {
        if (&p == &c || !finite_sample(p)) continue;
        const double dx = p.x - c.x, dy = p.y - c.y;
        const double distance2 = dx * dx + dy * dy;
        if (!std::isfinite(distance2)) continue;
        if (std::abs(dy) < 1e-9 && dx < 0 && distance2 < ld) { l = &p; ld = distance2; }
        if (std::abs(dy) < 1e-9 && dx > 0 && distance2 < rd) { r = &p; rd = distance2; }
        if (std::abs(dx) < 1e-9 && dy < 0 && distance2 < dd) { d = &p; dd = distance2; }
        if (std::abs(dx) < 1e-9 && dy > 0 && distance2 < ud) { u = &p; ud = distance2; }
    }

    if (l && r) s.dVdx = (r->volts - l->volts) / (r->x - l->x);
    else if (r) s.dVdx = (r->volts - c.volts) / (r->x - c.x);
    else if (l) s.dVdx = (c.volts - l->volts) / (c.x - l->x);
    if (d && u) s.dVdy = (u->volts - d->volts) / (u->y - d->y);
    else if (u) s.dVdy = (u->volts - c.volts) / (u->y - c.y);
    else if (d) s.dVdy = (c.volts - d->volts) / (c.y - d->y);

    if (!std::isfinite(s.dVdx)) s.dVdx = 0;
    if (!std::isfinite(s.dVdy)) s.dVdy = 0;
    s.magnitude = std::hypot(s.dVdx, s.dVdy);
    s.direction = std::atan2(s.dVdy, s.dVdx);

    double mean = 0;
    std::size_t count = 0;
    for (const auto& p : samples) if (finite_sample(p)) { mean += p.volts; ++count; }
    if (count == 0) return FieldState{};
    mean /= static_cast<double>(count);
    double variance = 0;
    for (const auto& p : samples) if (finite_sample(p)) {
        const double z = p.volts - mean;
        variance += z * z;
    }
    variance /= static_cast<double>(count);
    s.uniformity = std::isfinite(variance) ? 1.0 / (1.0 + std::sqrt(variance)) : 0.0;
    return s;
}

std::uint64_t field_to_input(const FieldState& s) {
    auto quantize = [](double x) -> std::uint64_t {
        if (!std::isfinite(x)) return 0;
        const double bounded = std::min(std::abs(x), 1048575.0 / 1000.0);
        return static_cast<std::uint64_t>(bounded * 1000.0);
    };
    // Fixed 64-bit layout: 20 bits each for voltage/magnitude, 20 for
    // uniformity, and 4 for direction. Mask before shifting to avoid overlap.
    const auto v = quantize(s.voltage) & 0xFFFFFULL;
    const auto m = quantize(s.magnitude) & 0xFFFFFULL;
    const auto u = quantize(s.uniformity) & 0xFFFFFULL;
    const auto d = quantize(s.direction) & 0xFULL;
    return (v << 44) | (m << 24) | (u << 4) | d;
}

} // namespace utf4088