kuramoto()

MAYAFLUX_API double MayaFlux::Kinesis::Discrete::kuramoto ( std::span< const double >  window, std::span< double >  coefs  )

noexcept

Kuramoto oscillators pulled toward their mean phase.

Each call advances every phase by its own increment plus coupling * r * sin(mean_phase - phase), where r e^(i mean_phase) is the mean of the phases on the unit circle, then returns the mean of the sines. With no coupling the group stays loose; past a critical coupling it locks, and the output grows as the phases align. Costs a few trigonometric calls per oscillator per call.

Definition at line 501 of file Kernels.cpp.

{
    if (coefs.size() < 2)
        return 0.0;
 
    const auto n = static_cast<size_t>(std::max(coefs.front(), 0.0));
    if (n == 0 || coefs.size() < 2 + 2 * n)
        return 0.0;
 
    const double coupling = coefs[1];
    const auto omegas = coefs.subspan(2, n);
    const auto phases = coefs.subspan(2 + n, n);
    const double inverse = 1.0 / static_cast<double>(n);
 
    constexpr size_t cached = 256;
    std::array<double, cached> cosines;
    std::array<double, cached> sines;
    const bool reuse = n <= cached;
 
    double field_cos = 0.0;
    double field_sin = 0.0;
    for (size_t i = 0; i < n; ++i) {
        const double c = std::cos(phases[i]);
        const double s = std::sin(phases[i]);
        if (reuse) {
            cosines[i] = c;
            sines[i] = s;
        }
        field_cos += c;
        field_sin += s;
    }
    field_cos *= inverse;
    field_sin *= inverse;
 
    double mix = 0.0;
    for (size_t i = 0; i < n; ++i) {
        const double c = reuse ? cosines[i] : std::cos(phases[i]);
        const double s = reuse ? sines[i] : std::sin(phases[i]);
        const double pull = coupling * (field_sin * c - field_cos * s);
        phases[i] += omegas[i] + pull;
        wrap_revolution(phases[i]);
        mix += std::sin(phases[i]);
    }
    return mix * inverse;
}