lagrange_weights()

MAYAFLUX_API void MayaFlux::Kinesis::Discrete::lagrange_weights ( double  delay, std::span< double >  weights  )

noexcept

Lagrange interpolation weights written to an array, without allocating.

Parameters

delay	Position between the taps, clamped to [0, taps - 1]
weights	Output; its size is the number of taps, so order = size - 1

The same weights as lagrange_delay for order = weights.size() - 1, for use per sample.

Definition at line 367 of file Coefficients.cpp.

{
    const size_t taps = weights.size();
    if (taps == 0)
        return;
 
    const double d = std::clamp(delay, 0.0, static_cast<double>(taps - 1));
 
    if (taps > reciprocal_factorial.size()) {
        for (size_t k = 0; k < taps; ++k) {
            weights[k] = 1.0;
            for (size_t j = 0; j < taps; ++j) {
                if (j == k)
                    continue;
                weights[k] *= (d - static_cast<double>(j))
                    / (static_cast<double>(k) - static_cast<double>(j));
            }
        }
        return;
    }
 
    double before = 1.0;
    for (size_t k = 0; k < taps; ++k) {
        weights[k] = before;
        before *= d - static_cast<double>(k);
    }
 
    double after = 1.0;
    for (size_t k = taps; k-- > 0;) {
        const size_t rest = taps - 1 - k;
        const double scale = reciprocal_factorial[k] * reciprocal_factorial[rest];
        weights[k] *= after * (rest % 2 == 0 ? scale : -scale);
        after *= d - static_cast<double>(k);
    }
}

References delay(), and MayaFlux::Kinesis::scale().

Referenced by lagrange_delay(), and MayaFlux::Buffers::FeedbackProcessor::read_at().

Here is the call graph for this function:

Here is the caller graph for this function: