max_pole_magnitude()

MAYAFLUX_API double MayaFlux::Kinesis::Discrete::max_pole_magnitude

(

std::span< const double >

a

)

Largest pole magnitude of a denominator polynomial.

Roots of a[0] + a[1]z^-1 + ... are found via the companion matrix eigenvalues. A return value below 1.0 indicates a stable recurrence; at or above 1.0 the recurrence diverges.

Orders 1 and 2 are closed-form. Higher orders carry an Eigen dependency.

Parameters

a	Denominator coefficients, a[0] must be non-zero

Returns

Largest |root|, or 0.0 for a constant polynomial

Definition at line 444 of file Coefficients.cpp.

{
    size_t order = a.size();
    while (order > 1 && a[order - 1] == 0.0)
        --order;
 
    if (order <= 1)
        return 0.0;
 
    const double a0 = a[0];
 
    if (order == 2)
        return std::abs(a[1] / a0);
 
    if (order == 3) {
        const double p = a[1] / a0;
        const double q = a[2] / a0;
        const double disc = p * p - 4.0 * q;
        if (disc >= 0.0) {
            const double r = std::sqrt(disc);
            return std::max(std::abs((-p + r) * 0.5), std::abs((-p - r) * 0.5));
        }
        return std::sqrt(q);
    }
 
    const Eigen::Index n = static_cast<Eigen::Index>(order) - 1;
    Eigen::MatrixXd companion = Eigen::MatrixXd::Zero(n, n);
    for (Eigen::Index i = 0; i < n; ++i)
        companion(0, i) = -a[static_cast<size_t>(i) + 1] / a0;
    for (Eigen::Index i = 1; i < n; ++i)
        companion(i, i - 1) = 1.0;
 
    Eigen::EigenSolver<Eigen::MatrixXd> solver(companion, false);
    double largest = 0.0;
    for (Eigen::Index i = 0; i < solver.eigenvalues().size(); ++i)
        largest = std::max(largest, std::abs(solver.eigenvalues()(i)));
    return largest;
}

References a, largest, q, and size.

Referenced by MayaFlux::Nodes::Filters::Filter::max_pole_magnitude().

Here is the caller graph for this function: