backward_difference() [1/2]

template<size_t N, typename T >

T MayaFlux::Kinesis::backward_difference ( const Memory::HistoryBuffer< T > &  history, double  dt  )

inlinenoexcept

N-th order backward finite difference of a HistoryBuffer, scaled by dt^N.

Template Parameters

N	Difference order. 1 velocity, 2 acceleration, 3 jerk, 4 jounce, 5 crackle, 6 pop.
T	Sample type. Must support operator+, operator-, and multiplication/division by scalar_t<T>.

Parameters

history	Buffer with capacity >= N + 1, [0] newest through [N] oldest used
dt	Elapsed time between consecutive samples, assumed uniform across all N intervals

Returns

sum_{k=0}^{N} (-1)^k * C(N,k) * history[k], divided by dt^N

Named wrappers below (velocity, acceleration, jerk, jounce, crackle, pop) are instantiations of this at fixed N. A caller needing N = 7 or higher calls backward_difference<7>(history, dt) directly.

dt == 0 is not guarded: the correct response depends on the caller's domain, so this stays a pure computation.

Uniform dt across all N intervals is an assumption, not a check. HistoryBuffer carries no per-sample timestamps.

HistoryBuffer::operator[] indexes modulo capacity, not modulo the number of samples actually pushed. Querying history[k] before k samples have been pushed reads the zero initial condition.

Definition at line 42 of file Differential.hpp.

{
    static_assert(N >= 1, "backward_difference<N> requires N >= 1; N = 0 is the sample itself");
 
    using S = scalar_t<T>;
 
    T acc = history[0];
    double binomial = 1.0;
 
    for (size_t k = 1; k <= N; ++k) {
        binomial = binomial * static_cast<double>(N - k + 1) / static_cast<double>(k);
        const double sign = (k % 2 == 0) ? 1.0 : -1.0;
        acc = acc + static_cast<S>(sign * binomial) * history[k];
    }
 
    double denom = 1.0;
    for (size_t i = 0; i < N; ++i)
        denom *= dt;
 
    return acc / static_cast<S>(denom);
}

References k, and N.