KALTECH V5 Feature Catalog

v5/lib/features_v5.py:831–836  ::  extract_features    # -----------------------------------------------------------------------
    # TIME-DOMAIN STATISTICAL (11 features)
    # -----------------------------------------------------------------------
    rms = float(np.sqrt(np.mean(signal ** 2)))
    peak = float(np.max(np.abs(signal)))
    crest_factor = peak / rms if rms > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:831–836  ::  extract_features    # -----------------------------------------------------------------------
    # TIME-DOMAIN STATISTICAL (11 features)
    # -----------------------------------------------------------------------
    rms = float(np.sqrt(np.mean(signal ** 2)))
    peak = float(np.max(np.abs(signal)))
    crest_factor = peak / rms if rms > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:838–844  ::  extract_features    mean = float(np.mean(signal))
    std_dev = float(np.std(signal))
    var = std_dev ** 2
    # Non-excess kurtosis: mu_4/sigma^4 (Gaussian = 3.0, NOT 0.0)
    # All downstream thresholds (4.0, 8.0) are calibrated to this definition.
    kurtosis = float(np.mean((signal - mean) ** 4) / (var ** 2)) if var > 0 else 0.0
    skewness = float(np.mean((signal - mean) ** 3) / (std_dev ** 3)) if std_dev > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:838–844  ::  extract_features    mean = float(np.mean(signal))
    std_dev = float(np.std(signal))
    var = std_dev ** 2
    # Non-excess kurtosis: mu_4/sigma^4 (Gaussian = 3.0, NOT 0.0)
    # All downstream thresholds (4.0, 8.0) are calibrated to this definition.
    kurtosis = float(np.mean((signal - mean) ** 4) / (var ** 2)) if var > 0 else 0.0
    skewness = float(np.mean((signal - mean) ** 3) / (std_dev ** 3)) if std_dev > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:838–844  ::  extract_features    mean = float(np.mean(signal))
    std_dev = float(np.std(signal))
    var = std_dev ** 2
    # Non-excess kurtosis: mu_4/sigma^4 (Gaussian = 3.0, NOT 0.0)
    # All downstream thresholds (4.0, 8.0) are calibrated to this definition.
    kurtosis = float(np.mean((signal - mean) ** 4) / (var ** 2)) if var > 0 else 0.0
    skewness = float(np.mean((signal - mean) ** 3) / (std_dev ** 3)) if std_dev > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:838–844  ::  extract_features    mean = float(np.mean(signal))
    std_dev = float(np.std(signal))
    var = std_dev ** 2
    # Non-excess kurtosis: mu_4/sigma^4 (Gaussian = 3.0, NOT 0.0)
    # All downstream thresholds (4.0, 8.0) are calibrated to this definition.
    kurtosis = float(np.mean((signal - mean) ** 4) / (var ** 2)) if var > 0 else 0.0
    skewness = float(np.mean((signal - mean) ** 3) / (std_dev ** 3)) if std_dev > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:838–844  ::  extract_features    mean = float(np.mean(signal))
    std_dev = float(np.std(signal))
    var = std_dev ** 2
    # Non-excess kurtosis: mu_4/sigma^4 (Gaussian = 3.0, NOT 0.0)
    # All downstream thresholds (4.0, 8.0) are calibrated to this definition.
    kurtosis = float(np.mean((signal - mean) ** 4) / (var ** 2)) if var > 0 else 0.0
    skewness = float(np.mean((signal - mean) ** 3) / (std_dev ** 3)) if std_dev > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:831–836  ::  extract_features    # -----------------------------------------------------------------------
    # TIME-DOMAIN STATISTICAL (11 features)
    # -----------------------------------------------------------------------
    rms = float(np.sqrt(np.mean(signal ** 2)))
    peak = float(np.max(np.abs(signal)))
    crest_factor = peak / rms if rms > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:846–849  ::  extract_features    abs_signal = np.abs(signal)
    mean_abs = float(np.mean(abs_signal))
    shape_factor = rms / mean_abs if mean_abs > 0 else 0.0
    impulse_factor = peak / mean_abs if mean_abs > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:846–849  ::  extract_features    abs_signal = np.abs(signal)
    mean_abs = float(np.mean(abs_signal))
    shape_factor = rms / mean_abs if mean_abs > 0 else 0.0
    impulse_factor = peak / mean_abs if mean_abs > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:851–852  ::  extract_features    mean_sqrt_abs = float(np.mean(np.sqrt(abs_signal)))
    clearance_factor = peak / (mean_sqrt_abs ** 2) if mean_sqrt_abs > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:863–863  ::  extract_features    dominant_freq_hz = float(freqs_ndc[np.argmax(mags_ndc)]) if len(mags_ndc) > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:869–872  ::  extract_features    if total_power > 0:
        weights = power / total_power
        spectral_centroid = float(np.sum(freqs_ndc * weights))
        spectral_bandwidth = float(np.sqrt(np.sum(((freqs_ndc - spectral_centroid) ** 2) * weights)))

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:869–872  ::  extract_features    if total_power > 0:
        weights = power / total_power
        spectral_centroid = float(np.sum(freqs_ndc * weights))
        spectral_bandwidth = float(np.sqrt(np.sum(((freqs_ndc - spectral_centroid) ** 2) * weights)))

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:874–877  ::  extract_features        # Rolloff: frequency below which 85% of spectral energy resides
        cumulative_energy = np.cumsum(power) / total_power
        rolloff_idx = np.searchsorted(cumulative_energy, 0.85)
        spectral_rolloff = float(freqs_ndc[min(rolloff_idx, len(freqs_ndc) - 1)])

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:879–889  ::  extract_features        # Flatness: geometric mean / arithmetic mean of power spectrum
        # High flatness → noise-like; low flatness → tonal/harmonic
        log_power = np.log(power + 1e-20)
        geo_mean = float(np.exp(np.mean(log_power)))
        arith_mean = float(np.mean(power))
        spectral_flatness = geo_mean / arith_mean if arith_mean > 0 else 0.0
    else:
        spectral_centroid = 0.0
        spectral_bandwidth = 0.0
        spectral_rolloff = 0.0
        spectral_flatness = 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:1054–1063  ::  extract_features    # Spectral entropy — disorder measure (0=pure tone, 1=white noise)
    if total_power > 0:
        p_norm = power / total_power
        p_nz = p_norm[p_norm > 1e-20]
        spectral_entropy = (
            float(-np.sum(p_nz * np.log2(p_nz))) / max(np.log2(len(p_nz)), 1.0)
            if len(p_nz) > 1 else 0.0
        )
    else:
        spectral_entropy = 0.0

firmware/common/dsp/kaltech_dsp.c:160–182  ::  kaltech_spectral_entropy_f32float kaltech_spectral_entropy_f32(const float *mag, size_t n) {
    size_t half = n / 2;
    double total = 0.0;
    for (size_t k = 1; k <= half; k++) {
        double m = mag[k];
        total += m * m;
    }
    if (total <= 0.0) return 0.0f;

    double ent = 0.0;
    int nz = 0;
    for (size_t k = 1; k <= half; k++) {
        double m = mag[k];
        double p = (m * m) / total;
        if (p > 1e-20) {
            ent -= p * (log(p) / log(2.0));
            nz++;
        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

v5/lib/features_v5.py:891–902  ::  extract_features    # Band energy ratios (low / mid / high thirds of Nyquist range)
    nyquist = fs / 2.0
    band_edges = [0.0, nyquist / 3.0, 2.0 * nyquist / 3.0, nyquist]
    band_energies = []
    for i in range(3):
        mask = (freqs >= band_edges[i]) & (freqs < band_edges[i + 1])
        band_e = float(np.sum(magnitudes[mask] ** 2))
        band_energies.append(band_e)
    total_band = sum(band_energies) + 1e-20
    band_energy_low = band_energies[0] / total_band
    band_energy_mid = band_energies[1] / total_band
    band_energy_high = band_energies[2] / total_band

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:891–902  ::  extract_features    # Band energy ratios (low / mid / high thirds of Nyquist range)
    nyquist = fs / 2.0
    band_edges = [0.0, nyquist / 3.0, 2.0 * nyquist / 3.0, nyquist]
    band_energies = []
    for i in range(3):
        mask = (freqs >= band_edges[i]) & (freqs < band_edges[i + 1])
        band_e = float(np.sum(magnitudes[mask] ** 2))
        band_energies.append(band_e)
    total_band = sum(band_energies) + 1e-20
    band_energy_low = band_energies[0] / total_band
    band_energy_mid = band_energies[1] / total_band
    band_energy_high = band_energies[2] / total_band

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:891–902  ::  extract_features    # Band energy ratios (low / mid / high thirds of Nyquist range)
    nyquist = fs / 2.0
    band_edges = [0.0, nyquist / 3.0, 2.0 * nyquist / 3.0, nyquist]
    band_energies = []
    for i in range(3):
        mask = (freqs >= band_edges[i]) & (freqs < band_edges[i + 1])
        band_e = float(np.sum(magnitudes[mask] ** 2))
        band_energies.append(band_e)
    total_band = sum(band_energies) + 1e-20
    band_energy_low = band_energies[0] / total_band
    band_energy_mid = band_energies[1] / total_band
    band_energy_high = band_energies[2] / total_band

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:1044–1052  ::  extract_features    # -----------------------------------------------------------------------
    # ADDITIONAL SPECTRAL (2 features)
    # -----------------------------------------------------------------------
    # Band energy ultrasonic (>10 kHz) — SKF Stage 1 detection
    if nyquist > 10000:
        mask_ultra = freqs >= 10000
        band_energy_ultrasonic = float(np.sum(magnitudes[mask_ultra] ** 2)) / (total_band + 1e-20)
    else:
        band_energy_ultrasonic = 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_featuresvoid kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {
            if (freq >= band_edges[b] && freq < band_edges[b + 1]) band[b] += p;
        }
        if (freq >= 10000.0) band_ultra += p;
    }
    double denom = total_band + 1e-20;
    out->band_energy_low        = (float)(band[0] / denom);
    out->band_energy_mid        = (float)(band[1] / denom);
    out->band_energy_high       = (float)(band[2] / denom);
    out->band_energy_ultrasonic = (nyq > 10000.0f) ? (float)(band_ultra / denom) : 0.0f;
}

v5/lib/features_v5.py:717–745  ::  compute_rms_velocitydef compute_rms_velocity(signal: np.ndarray, fs: int = CWRU_FS) -> float:
    """
    Integrate acceleration signal to velocity and compute RMS in mm/s.

    ISO 10816-1 specifies velocity RMS in the 10-1000 Hz band.
    Integration via cumulative trapezoidal rule, followed by 10-1000 Hz
    bandpass filter, then RMS computation.

    Args:
        signal: 1-D acceleration time series (assumed pre-calibrated in g or m/s²).
        fs:     Sampling frequency in Hz.

    Returns:
        RMS velocity in mm/s per ISO 10816-1 (10-1000 Hz band).
    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0
    lo = max(10.0 / nyquist, 0.001)
    hi = min(1000.0 / nyquist, 0.99)
    if lo < hi:
        b, a = butter(4, [lo, hi], btype="band")
        velocity_mm_s = filtfilt(b, a, velocity_mm_s)
    return float(np.sqrt(np.mean(velocity_mm_s ** 2)))

firmware/common/dsp/kaltech_dsp.c:1127–1153  ::  kaltech_iso_velocity_rms_f32float kaltech_iso_velocity_rms_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    /* cumulative trapezoid: v[0] = 0; v[i] = v[i-1] + 0.5*(x[i-1]+x[i])*dt */
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;

    /* Remove linear drift: v -= linspace(v[0], v[-1], n). v[0]=0, so just
     * subtract i/(n-1) * v[-1]. */
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;

    /* g·s → mm/s */
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;

    /* Bandpass 10–1000 Hz, filtfilt */
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);

    /* RMS */
    double ss = 0.0;
    for (size_t i = 0; i < n; i++) ss += (double)kal_env_tmp2[i] * (double)kal_env_tmp2[i];
    return (float)sqrt(ss / (double)n);
}

v5/lib/features_v5.py:717–745  ::  compute_rms_velocitydef compute_rms_velocity(signal: np.ndarray, fs: int = CWRU_FS) -> float:
    """
    Integrate acceleration signal to velocity and compute RMS in mm/s.

    ISO 10816-1 specifies velocity RMS in the 10-1000 Hz band.
    Integration via cumulative trapezoidal rule, followed by 10-1000 Hz
    bandpass filter, then RMS computation.

    Args:
        signal: 1-D acceleration time series (assumed pre-calibrated in g or m/s²).
        fs:     Sampling frequency in Hz.

    Returns:
        RMS velocity in mm/s per ISO 10816-1 (10-1000 Hz band).
    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0
    lo = max(10.0 / nyquist, 0.001)
    hi = min(1000.0 / nyquist, 0.99)
    if lo < hi:
        b, a = butter(4, [lo, hi], btype="band")
        velocity_mm_s = filtfilt(b, a, velocity_mm_s)
    return float(np.sqrt(np.mean(velocity_mm_s ** 2)))

firmware/common/dsp/kaltech_dsp.c:1156–1175  ::  kaltech_iso_velocity_peak_f32float kaltech_iso_velocity_peak_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);
    float peak = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float a = fabsf(kal_env_tmp2[i]);
        if (a > peak) peak = a;
    }
    return peak;
}

v5/lib/features_v5.py:1337–1451  ::  extract_randall_featuresdef extract_randall_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, Any]:
    """
    Extract advanced diagnostic features using Randall's techniques.

    Complements extract_features() with:
    - Cepstrum-based periodicity detection
    - Spectral kurtosis band selection
    - Optimal-band envelope analysis
    """
    features: dict[str, Any] = {}

    # --- Cepstrum analysis ---
    quefrency, cepstrum = compute_cepstrum(signal, fs)

    # Peak cepstrum value (excluding near-zero quefrency)
    min_quef = 0.002  # 2ms minimum (500 Hz max)
    max_quef = 0.1    # 100ms maximum (10 Hz min)
    mask = (quefrency >= min_quef) & (quefrency <= max_quef)
    if np.any(mask):
        peak_idx = np.argmax(cepstrum[mask])
        features["cepstrum_peak_quefrency"] = float(quefrency[mask][peak_idx])
        features["cepstrum_peak_magnitude"] = float(cepstrum[mask][peak_idx])
        features["cepstrum_peak_freq"] = (
            1.0 / features["cepstrum_peak_quefrency"]
            if features["cepstrum_peak_quefrency"] > 0
            else 0.0
        )
    else:
        features["cepstrum_peak_quefrency"] = 0.0
        features["cepstrum_peak_magnitude"] = 0.0
        features["cepstrum_peak_freq"] = 0.0

    # Check if cepstrum peak matches any defect frequency.
    # A bearing impact train has cepstrum peaks at the IMPACT PERIOD (1/BPFO)
    # AND its integer multiples (2/BPFO, 3/BPFO, ...). Original implementation
    # only matched the fundamental cep_freq vs defect freq within ±5%, which
    # missed signals where the algorithm picked a higher cepstral harmonic.
    # Fix: check if peak_quefrency × defect_freq is within ±10% of any integer
    # K ∈ [1, 5]. K=1 reduces to the original test (slightly relaxed), K≥2
    # captures higher-order cepstral harmonics. Mirrors firmware fix in
    # kaltech_cepstrum_extended_f32.
    # cepstrum_defect_match: categorical {none, bpfo, bpfi, bsf, ftf}.
    # Pre-seed to "none" so the key always exists in the returned dict —
    # downstream callers (services/features_api/main.py contract check,
    # NPZ training pipeline) require stable schema regardless of whether
    # rpm is provided. Wave-2 fix C-1.
    features["cepstrum_defect_match"] = "none"
    if rpm is not None and rpm > 0:
        defect_freqs = bearing_defect_freqs(rpm, bearing_type)
        peak_q = features["cepstrum_peak_quefrency"]
        if peak_q > 0:
            best_err = 1e30
            best_name = "none"
            for name, freq in defect_freqs.items():
                if freq <= 0:
                    continue
                qf = peak_q * freq
                K = int(round(qf))
                if K < 1 or K > 5:
                    continue
                err = abs(qf - K) / K
                if err < 0.10 and err < best_err:
                    best_err = err
                    best_name = name
            features["cepstrum_defect_match"] = best_name

    # --- Spectral kurtosis ---
    f_sk, sk = compute_spectral_kurtosis(signal, fs)
    features["sk_max"] = float(np.max(sk[f_sk > 50])) if np.any(f_sk > 50) else 0.0
    features["sk_mean"] = float(np.mean(sk[f_sk > 50])) if np.any(f_sk > 50) else 0.0

    # --- Optimal demodulation band (kurtogram) ---
    opt_band = find_optimal_demod_band(signal, fs)
    features["optimal_band_center"] = opt_band["center_freq"]
    features["optimal_band_bw"] = opt_band["bandwidth"]
# … 35 more lines truncated …

firmware/common/dsp/kaltech_dsp.h:396–396  ::  kaltech_per_axis_feats_t::rms_acceleration_g    float rms_acceleration_g, pp_displacement_um;

v5/lib/features_v5.py:1337–1451  ::  extract_randall_featuresdef extract_randall_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, Any]:
    """
    Extract advanced diagnostic features using Randall's techniques.

    Complements extract_features() with:
    - Cepstrum-based periodicity detection
    - Spectral kurtosis band selection
    - Optimal-band envelope analysis
    """
    features: dict[str, Any] = {}

    # --- Cepstrum analysis ---
    quefrency, cepstrum = compute_cepstrum(signal, fs)

    # Peak cepstrum value (excluding near-zero quefrency)
    min_quef = 0.002  # 2ms minimum (500 Hz max)
    max_quef = 0.1    # 100ms maximum (10 Hz min)
    mask = (quefrency >= min_quef) & (quefrency <= max_quef)
    if np.any(mask):
        peak_idx = np.argmax(cepstrum[mask])
        features["cepstrum_peak_quefrency"] = float(quefrency[mask][peak_idx])
        features["cepstrum_peak_magnitude"] = float(cepstrum[mask][peak_idx])
        features["cepstrum_peak_freq"] = (
            1.0 / features["cepstrum_peak_quefrency"]
            if features["cepstrum_peak_quefrency"] > 0
            else 0.0
        )
    else:
        features["cepstrum_peak_quefrency"] = 0.0
        features["cepstrum_peak_magnitude"] = 0.0
        features["cepstrum_peak_freq"] = 0.0

    # Check if cepstrum peak matches any defect frequency.
    # A bearing impact train has cepstrum peaks at the IMPACT PERIOD (1/BPFO)
    # AND its integer multiples (2/BPFO, 3/BPFO, ...). Original implementation
    # only matched the fundamental cep_freq vs defect freq within ±5%, which
    # missed signals where the algorithm picked a higher cepstral harmonic.
    # Fix: check if peak_quefrency × defect_freq is within ±10% of any integer
    # K ∈ [1, 5]. K=1 reduces to the original test (slightly relaxed), K≥2
    # captures higher-order cepstral harmonics. Mirrors firmware fix in
    # kaltech_cepstrum_extended_f32.
    # cepstrum_defect_match: categorical {none, bpfo, bpfi, bsf, ftf}.
    # Pre-seed to "none" so the key always exists in the returned dict —
    # downstream callers (services/features_api/main.py contract check,
    # NPZ training pipeline) require stable schema regardless of whether
    # rpm is provided. Wave-2 fix C-1.
    features["cepstrum_defect_match"] = "none"
    if rpm is not None and rpm > 0:
        defect_freqs = bearing_defect_freqs(rpm, bearing_type)
        peak_q = features["cepstrum_peak_quefrency"]
        if peak_q > 0:
            best_err = 1e30
            best_name = "none"
            for name, freq in defect_freqs.items():
                if freq <= 0:
                    continue
                qf = peak_q * freq
                K = int(round(qf))
                if K < 1 or K > 5:
                    continue
                err = abs(qf - K) / K
                if err < 0.10 and err < best_err:
                    best_err = err
                    best_name = name
            features["cepstrum_defect_match"] = best_name

    # --- Spectral kurtosis ---
    f_sk, sk = compute_spectral_kurtosis(signal, fs)
    features["sk_max"] = float(np.max(sk[f_sk > 50])) if np.any(f_sk > 50) else 0.0
    features["sk_mean"] = float(np.mean(sk[f_sk > 50])) if np.any(f_sk > 50) else 0.0

    # --- Optimal demodulation band (kurtogram) ---
    opt_band = find_optimal_demod_band(signal, fs)
    features["optimal_band_center"] = opt_band["center_freq"]
    features["optimal_band_bw"] = opt_band["bandwidth"]
# … 35 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1177–1208  ::  kaltech_pp_displacement_um_f32float kaltech_pp_displacement_um_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1]
                        + 0.5f * (x[i - 1] + x[i]) * 9.81f * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    kal_env_tmp3[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp3[i] = kal_env_tmp3[i - 1]
                        + 0.5f * (kal_env_tmp1[i - 1] + kal_env_tmp1[i]) * dt;
    float d_end = kal_env_tmp3[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp3[i] -= (float)i / (float)(n - 1) * d_end;
    /* ISO 20816-3 displacement bandpass — Python features.py:691 specifies
     * butter(2, [max(2/nyq, 0.001), min(100/nyq, 0.99)], btype='band'). At
     * fs=12000 the lower-cutoff floor activates and the EFFECTIVE band is
     * [6, 100] Hz (not the [2, 100] the comment used to claim). The SOS
     * catalog entry KAL_FILT_DISP_PP is designed against the effective
     * band so parity holds bit-exact. See firmware/common/dsp/kaltech_filter_coeffs.h. */
    kaltech_sos_filtfilt_f32(KAL_FILT_DISP_PP_COEFFS, KAL_FILT_DISP_PP_N_SEC,
                             kal_env_tmp3, n, kal_env_tmp2);
    float mn = kal_env_tmp2[0], mx = kal_env_tmp2[0];
    for (size_t i = 1; i < n; i++) {
        if (kal_env_tmp2[i] < mn) mn = kal_env_tmp2[i];
        if (kal_env_tmp2[i] > mx) mx = kal_env_tmp2[i];
    }
    return (mx - mn) * 1e6f;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.c:945–956  ::  kaltech_energy_near_f32float kaltech_energy_near_f32(const float *env_mag, size_t n, float fs,
                              float target_hz, float bw_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    float lo = target_hz - bw_hz, hi = target_hz + bw_hz;
    float sum = 0.0f;
    for (size_t k = 0; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        if (freq >= lo && freq <= hi) sum += env_mag[k] * env_mag[k];
    }
    return sum;
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:336–382  ::  envelope_spectrumdef envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new drs_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

    return freqs, fft_env

firmware/common/dsp/kaltech_dsp.c:612–650  ::  kaltech_envelope_spectrum_f32void kaltech_envelope_spectrum_f32(const float *x, size_t n,
                                   const float *sos_coeffs, int n_sec,
                                   float *env_mag_out) {
    /* Per parity-porting.md "Empty-result must be a SENTINEL, not a zero":
     * on guard / init failure, zero the full output range so a caller
     * iterating env_mag_out[0..n/2] sees explicit zeros rather than stale
     * heap/stack from a previous call. Same pattern as
     * kaltech_squared_envelope_spectrum_f32 below. */
    if (n == 0 || n > KAL_FFT_MAX_N) {
        return;  /* n is unusable — caller cannot iterate output safely. */
    }
    /* Pre-zero so any subsequent early-return is sentinel-safe. */
    for (size_t k = 0; k <= n / 2; k++) env_mag_out[k] = 0.0f;
    /* 1. Bandpass filter. */
    kaltech_sos_filtfilt_f32(sos_coeffs, n_sec, x, n, kal_env_tmp1);
    /* 2. Hilbert envelope. */
    kaltech_hilbert_envelope_f32(kal_env_tmp1, n, kal_env_tmp2);
    /* 3. Remove DC. */
    float mean = 0.0f;
    for (size_t i = 0; i < n; i++) mean += kal_env_tmp2[i];
    mean /= (float)n;
    for (size_t i = 0; i < n; i++) kal_env_tmp2[i] -= mean;
    /* 4. |rfft(envelope)| / N — matches scipy's envelope_spectrum line 234:
     *    fft_env = np.abs(np.fft.rfft(envelope)) / N
     */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;
    for (size_t i = 0; i < n; i++) kal_env_tmp3[i] = kal_env_tmp2[i];
    arm_rfft_fast_f32(&S, kal_env_tmp3, kal_fft_work_pack, 0);

    size_t half = n / 2;
    float inv_n = 1.0f / (float)n;
    env_mag_out[0]    = fabsf(kal_fft_work_pack[0]) * inv_n;
    env_mag_out[half] = fabsf(kal_fft_work_pack[1]) * inv_n;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2 * k], im = kal_fft_work_pack[2 * k + 1];
        env_mag_out[k] = sqrtf(re * re + im * im) * inv_n;
    }
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:1088–1125  ::  kaltech_optimal_envelope_featuresvoid kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */
    static float env_mag_opt[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(x, n, band->coeffs, KAL_BANK_N_SECTIONS,
                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:390–473  ::  drs_squared_envelope_featuresdef drs_squared_envelope_features(
    signal: np.ndarray,
    fs: int,
    bpfo: float,
    bpfi: float,
    bsf: float,
    ftf: float,
    kurt_center_hz: float,
    kurt_bw_hz: float,
) -> dict[str, float]:
    """V5 helper: DRS residual → squared envelope → energies at 1x/2x/3x of all
    bearing defect frequencies, in BOTH broadband and kurtogram-selected bands.

    Returns 24 keys:
      drs_sq_env_{bpfo,bpfi,bsf,ftf}                  (broadband, 1x)
      drs_sq_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}          (broadband, 2x/3x harmonics)
      drs_sq_optimal_env_{bpfo,bpfi,bsf,ftf}          (kurtogram band, 1x)
      drs_sq_optimal_env_{2x,3x}_{bpfo,bpfi,bsf,ftf}  (kurtogram band, 2x/3x)

    Combined V5 transformation: signal → DRS-residual → bandpass → hilbert →
    envelope² → rfft → energy_near(defect_freq * k) for k ∈ {1, 2, 3}.

    Randall §3.6.6 (DRS) + §5.5 (squared envelope, Fig 5.39): the squared
    envelope is the canonical bearing diagnostic; DRS strips deterministic
    rotation-locked content (gears, shaft harmonics, electrical line) so
    impulsive bearing-defect energy stands out cleanly.
    """
    names = ("bpfo", "bpfi", "bsf", "ftf")
    freqs_in = {"bpfo": bpfo, "bpfi": bpfi, "bsf": bsf, "ftf": ftf}

    out: dict[str, float] = {}
    for name in names:
        out[f"drs_sq_env_{name}"] = 0.0
        out[f"drs_sq_env_2x_{name}"] = 0.0
        out[f"drs_sq_env_3x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_{name}"] = 0.0
        out[f"drs_sq_optimal_env_2x_{name}"] = 0.0
        out[f"drs_sq_optimal_env_3x_{name}"] = 0.0

    if len(signal) < 32:
        return out

    drs_resid = drs(signal)
    nyq = fs * 0.5

    # Broadband squared envelope
    e_freqs, e_mags = envelope_spectrum(drs_resid, fs=fs, squared=True)
    for name in names:
        f = freqs_in[name]
        if f <= 0:
            continue
        for k_idx, k in enumerate((1.0, 2.0, 3.0)):
            f_at_k = k * f
            if f_at_k >= nyq:
                continue
            bw = 5.0 if k == 1.0 else 3.0  # tighter bandwidth at harmonics
            key = f"drs_sq_env_{name}" if k == 1.0 else f"drs_sq_env_{int(k)}x_{name}"
            out[key] = _energy_near(e_freqs, e_mags, f_at_k, bandwidth_hz=bw)

    # Kurtogram-band squared envelope (only if a valid kurtogram band exists)
    if kurt_bw_hz >= 50.0:
        lo = max(50.0, kurt_center_hz - kurt_bw_hz * 0.5)
        hi = min(nyq - 50.0, kurt_center_hz + kurt_bw_hz * 0.5)
        if hi > lo + 50.0:
            o_freqs, o_mags = envelope_spectrum(
                drs_resid, fs=fs, band_low=lo, band_high=hi, squared=True
            )
            for name in names:
                f = freqs_in[name]
                if f <= 0:
                    continue
                for k in (1.0, 2.0, 3.0):
                    f_at_k = k * f
                    if f_at_k >= nyq:
                        continue
                    bw = 3.0
                    key = (
                        f"drs_sq_optimal_env_{name}"
                        if k == 1.0
                        else f"drs_sq_optimal_env_{int(k)}x_{name}"
# … 4 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:850–943  ::  kaltech_drs_squared_envelope_featuresvoid kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[1] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[2] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[3] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Broadband 2x — slots 4-7 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[4] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[5] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq)
        out_24[6] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq)
        out_24[7] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 2*ftf_hz,  BW_HARM);
    /* Broadband 3x — slots 8-11 */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;
    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    static float drs_sq_opt_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n, band->coeffs, KAL_BANK_N_SECTIONS, drs_sq_opt_env_mag);

    /* Optimal 1x — slots 12-15 (bandwidth 5 Hz for 1x per Python) */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[12] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
        out_24[13] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bpfi_hz, BW_1X);
    if (bsf_hz  > 0 && bsf_hz  < nyq)
        out_24[14] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, bsf_hz,  BW_1X);
    if (ftf_hz  > 0 && ftf_hz  < nyq)
        out_24[15] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, ftf_hz,  BW_1X);
    /* Optimal 2x — slots 16-19 */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq)
        out_24[16] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq)
        out_24[17] = kaltech_energy_near_f32(drs_sq_opt_env_mag, n, fs, 2*bpfi_hz, BW_HARM);
# … 14 more lines truncated …

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.h:410–410  ::  kaltech_per_axis_feats_t::harmonic_1x    float harmonic_1x, harmonic_2x, harmonic_3x;

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.h:410–410  ::  kaltech_per_axis_feats_t::harmonic_1x    float harmonic_1x, harmonic_2x, harmonic_3x;

v5/lib/features_v5.py:752–760  ::  _energy_neardef _energy_near(
    freqs: np.ndarray,
    magnitudes: np.ndarray,
    target_hz: float,
    bandwidth_hz: float = 5.0,
) -> float:
    """Return total spectral energy within ±bandwidth_hz of target_hz."""
    mask = np.abs(freqs - target_hz) <= bandwidth_hz
    return float(np.sum(magnitudes[mask] ** 2))

firmware/common/dsp/kaltech_dsp.h:410–410  ::  kaltech_per_axis_feats_t::harmonic_1x    float harmonic_1x, harmonic_2x, harmonic_3x;

v5/lib/features_v5.py:525–551  ::  compute_cepstrumdef compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

    The cepstrum = IFFT(log(|FFT(x)|)) reveals periodicity in the spectrum.
    Peaks in the cepstrum (called "rahmonics") indicate:
    - Bearing defects: peak at 1/defect_freq (e.g., 1/BPFO)
    - Gear mesh: peak at 1/mesh_freq
    - Echo/reflection: peak at delay time

    Returns:
        (quefrency, cepstrum) — quefrency axis in seconds, cepstrum magnitudes
    """
    N = len(signal)
    windowed = signal * np.hanning(N)

    fft_mag = np.abs(np.fft.rfft(windowed))
    fft_mag = np.maximum(fft_mag, 1e-20)  # avoid log(0)

    log_spectrum = np.log(fft_mag)
    cepstrum = np.fft.irfft(log_spectrum)

    quefrency = np.arange(len(cepstrum)) / fs
    return quefrency, np.abs(cepstrum)

firmware/common/dsp/kaltech_dsp.c:1210–1321  ::  kaltech_cepstrum_extended_f32void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
    float nyq_mag = fabsf(kal_fft_work_pack[1]);
    log_mag_packed[0] = logf(dc_mag  > 1e-20f ? dc_mag  : 1e-20f);
    log_mag_packed[1] = logf(nyq_mag > 1e-20f ? nyq_mag : 1e-20f);
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2*k], im = kal_fft_work_pack[2*k + 1];
        float mag = sqrtf(re*re + im*im);
        log_mag_packed[2*k]     = logf(mag > 1e-20f ? mag : 1e-20f);
        log_mag_packed[2*k + 1] = 0.0f;
    }

    arm_rfft_fast_f32(&S, log_mag_packed, cepstrum, 1);

    /* Peak search over defect-period quefrency band [0.002 s, 0.1 s] —
     * defect frequencies 10–500 Hz. Matches features.py:942-946 mask
     * (quefrency >= 0.002) & (quefrency <= 0.1). Without this mask, the
     * argmax lands in the spectral-envelope region (k < 24 at fs=12000)
     * which is not a defect-period peak. Citation: Randall, "Frequency
     * Analysis" (Wiley 2011) Ch. 8 — bound by min/max defect period. */
    const float MIN_QUEF_S = 0.002f;
    const float MAX_QUEF_S = 0.1f;
    size_t lo = (size_t)((MIN_QUEF_S * fs) + 0.999999f);   /* ceil */
    size_t hi = (size_t)(MAX_QUEF_S * fs);                  /* floor */
    if (hi >= n / 2) hi = n / 2 - 1;
    if (lo > hi) {
        /* Mask empty (e.g. very short window). Outputs already zero from memset. */
        return;
    }
    /* Initialize peak to first masked value to match np.argmax tie-break:
     * if every value is identical, np.argmax returns the first index. */
    float peak = fabsf(cepstrum[lo]);
    size_t argmax = lo;
    for (size_t k = lo + 1; k <= hi; k++) {
        float a = fabsf(cepstrum[k]);
        if (a > peak) { peak = a; argmax = k; }   /* strict > matches np.argmax */
    }
    out->peak_magnitude   = peak;
    out->peak_quefrency_s = (float)argmax / fs;
    out->peak_freq_hz     = argmax > 0 ? fs / (float)argmax : 0.0f;

    /* Defect match: a bearing-impact cepstrum has peaks at the IMPACT PERIOD
     * (1/BPFO) AND its integer multiples (2/BPFO, 3/BPFO, ...). The original
     * implementation only matched the fundamental cep_freq vs defect freq
     * within ±5% — physically valid but very narrow. On shaft-dominated
     * signals the cepstrum peak lands at 1/shaft and never matches BPFO/
     * BPFI/BSF/FTF, returning 0 every record.
     *
     * Robust check (still matches Python features.py:967-975 on the
     * fundamental case): compare peak_quefrency × defect_freq against the
     * nearest integer K ∈ [1, 5]. If |Q·F - K| < 0.10 (10% tolerance on
# … 32 more lines truncated …

v5/lib/features_v5.py:525–551  ::  compute_cepstrumdef compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

    The cepstrum = IFFT(log(|FFT(x)|)) reveals periodicity in the spectrum.
    Peaks in the cepstrum (called "rahmonics") indicate:
    - Bearing defects: peak at 1/defect_freq (e.g., 1/BPFO)
    - Gear mesh: peak at 1/mesh_freq
    - Echo/reflection: peak at delay time

    Returns:
        (quefrency, cepstrum) — quefrency axis in seconds, cepstrum magnitudes
    """
    N = len(signal)
    windowed = signal * np.hanning(N)

    fft_mag = np.abs(np.fft.rfft(windowed))
    fft_mag = np.maximum(fft_mag, 1e-20)  # avoid log(0)

    log_spectrum = np.log(fft_mag)
    cepstrum = np.fft.irfft(log_spectrum)

    quefrency = np.arange(len(cepstrum)) / fs
    return quefrency, np.abs(cepstrum)

firmware/common/dsp/kaltech_dsp.c:1210–1321  ::  kaltech_cepstrum_extended_f32void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
    float nyq_mag = fabsf(kal_fft_work_pack[1]);
    log_mag_packed[0] = logf(dc_mag  > 1e-20f ? dc_mag  : 1e-20f);
    log_mag_packed[1] = logf(nyq_mag > 1e-20f ? nyq_mag : 1e-20f);
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2*k], im = kal_fft_work_pack[2*k + 1];
        float mag = sqrtf(re*re + im*im);
        log_mag_packed[2*k]     = logf(mag > 1e-20f ? mag : 1e-20f);
        log_mag_packed[2*k + 1] = 0.0f;
    }

    arm_rfft_fast_f32(&S, log_mag_packed, cepstrum, 1);

    /* Peak search over defect-period quefrency band [0.002 s, 0.1 s] —
     * defect frequencies 10–500 Hz. Matches features.py:942-946 mask
     * (quefrency >= 0.002) & (quefrency <= 0.1). Without this mask, the
     * argmax lands in the spectral-envelope region (k < 24 at fs=12000)
     * which is not a defect-period peak. Citation: Randall, "Frequency
     * Analysis" (Wiley 2011) Ch. 8 — bound by min/max defect period. */
    const float MIN_QUEF_S = 0.002f;
    const float MAX_QUEF_S = 0.1f;
    size_t lo = (size_t)((MIN_QUEF_S * fs) + 0.999999f);   /* ceil */
    size_t hi = (size_t)(MAX_QUEF_S * fs);                  /* floor */
    if (hi >= n / 2) hi = n / 2 - 1;
    if (lo > hi) {
        /* Mask empty (e.g. very short window). Outputs already zero from memset. */
        return;
    }
    /* Initialize peak to first masked value to match np.argmax tie-break:
     * if every value is identical, np.argmax returns the first index. */
    float peak = fabsf(cepstrum[lo]);
    size_t argmax = lo;
    for (size_t k = lo + 1; k <= hi; k++) {
        float a = fabsf(cepstrum[k]);
        if (a > peak) { peak = a; argmax = k; }   /* strict > matches np.argmax */
    }
    out->peak_magnitude   = peak;
    out->peak_quefrency_s = (float)argmax / fs;
    out->peak_freq_hz     = argmax > 0 ? fs / (float)argmax : 0.0f;

    /* Defect match: a bearing-impact cepstrum has peaks at the IMPACT PERIOD
     * (1/BPFO) AND its integer multiples (2/BPFO, 3/BPFO, ...). The original
     * implementation only matched the fundamental cep_freq vs defect freq
     * within ±5% — physically valid but very narrow. On shaft-dominated
     * signals the cepstrum peak lands at 1/shaft and never matches BPFO/
     * BPFI/BSF/FTF, returning 0 every record.
     *
     * Robust check (still matches Python features.py:967-975 on the
     * fundamental case): compare peak_quefrency × defect_freq against the
     * nearest integer K ∈ [1, 5]. If |Q·F - K| < 0.10 (10% tolerance on
# … 32 more lines truncated …

v5/lib/features_v5.py:525–551  ::  compute_cepstrumdef compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

    The cepstrum = IFFT(log(|FFT(x)|)) reveals periodicity in the spectrum.
    Peaks in the cepstrum (called "rahmonics") indicate:
    - Bearing defects: peak at 1/defect_freq (e.g., 1/BPFO)
    - Gear mesh: peak at 1/mesh_freq
    - Echo/reflection: peak at delay time

    Returns:
        (quefrency, cepstrum) — quefrency axis in seconds, cepstrum magnitudes
    """
    N = len(signal)
    windowed = signal * np.hanning(N)

    fft_mag = np.abs(np.fft.rfft(windowed))
    fft_mag = np.maximum(fft_mag, 1e-20)  # avoid log(0)

    log_spectrum = np.log(fft_mag)
    cepstrum = np.fft.irfft(log_spectrum)

    quefrency = np.arange(len(cepstrum)) / fs
    return quefrency, np.abs(cepstrum)

firmware/common/dsp/kaltech_dsp.c:1210–1321  ::  kaltech_cepstrum_extended_f32void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
    float nyq_mag = fabsf(kal_fft_work_pack[1]);
    log_mag_packed[0] = logf(dc_mag  > 1e-20f ? dc_mag  : 1e-20f);
    log_mag_packed[1] = logf(nyq_mag > 1e-20f ? nyq_mag : 1e-20f);
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2*k], im = kal_fft_work_pack[2*k + 1];
        float mag = sqrtf(re*re + im*im);
        log_mag_packed[2*k]     = logf(mag > 1e-20f ? mag : 1e-20f);
        log_mag_packed[2*k + 1] = 0.0f;
    }

    arm_rfft_fast_f32(&S, log_mag_packed, cepstrum, 1);

    /* Peak search over defect-period quefrency band [0.002 s, 0.1 s] —
     * defect frequencies 10–500 Hz. Matches features.py:942-946 mask
     * (quefrency >= 0.002) & (quefrency <= 0.1). Without this mask, the
     * argmax lands in the spectral-envelope region (k < 24 at fs=12000)
     * which is not a defect-period peak. Citation: Randall, "Frequency
     * Analysis" (Wiley 2011) Ch. 8 — bound by min/max defect period. */
    const float MIN_QUEF_S = 0.002f;
    const float MAX_QUEF_S = 0.1f;
    size_t lo = (size_t)((MIN_QUEF_S * fs) + 0.999999f);   /* ceil */
    size_t hi = (size_t)(MAX_QUEF_S * fs);                  /* floor */
    if (hi >= n / 2) hi = n / 2 - 1;
    if (lo > hi) {
        /* Mask empty (e.g. very short window). Outputs already zero from memset. */
        return;
    }
    /* Initialize peak to first masked value to match np.argmax tie-break:
     * if every value is identical, np.argmax returns the first index. */
    float peak = fabsf(cepstrum[lo]);
    size_t argmax = lo;
    for (size_t k = lo + 1; k <= hi; k++) {
        float a = fabsf(cepstrum[k]);
        if (a > peak) { peak = a; argmax = k; }   /* strict > matches np.argmax */
    }
    out->peak_magnitude   = peak;
    out->peak_quefrency_s = (float)argmax / fs;
    out->peak_freq_hz     = argmax > 0 ? fs / (float)argmax : 0.0f;

    /* Defect match: a bearing-impact cepstrum has peaks at the IMPACT PERIOD
     * (1/BPFO) AND its integer multiples (2/BPFO, 3/BPFO, ...). The original
     * implementation only matched the fundamental cep_freq vs defect freq
     * within ±5% — physically valid but very narrow. On shaft-dominated
     * signals the cepstrum peak lands at 1/shaft and never matches BPFO/
     * BPFI/BSF/FTF, returning 0 every record.
     *
     * Robust check (still matches Python features.py:967-975 on the
     * fundamental case): compare peak_quefrency × defect_freq against the
     * nearest integer K ∈ [1, 5]. If |Q·F - K| < 0.10 (10% tolerance on
# … 32 more lines truncated …

v5/lib/features_v5.py:525–551  ::  compute_cepstrumdef compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

    The cepstrum = IFFT(log(|FFT(x)|)) reveals periodicity in the spectrum.
    Peaks in the cepstrum (called "rahmonics") indicate:
    - Bearing defects: peak at 1/defect_freq (e.g., 1/BPFO)
    - Gear mesh: peak at 1/mesh_freq
    - Echo/reflection: peak at delay time

    Returns:
        (quefrency, cepstrum) — quefrency axis in seconds, cepstrum magnitudes
    """
    N = len(signal)
    windowed = signal * np.hanning(N)

    fft_mag = np.abs(np.fft.rfft(windowed))
    fft_mag = np.maximum(fft_mag, 1e-20)  # avoid log(0)

    log_spectrum = np.log(fft_mag)
    cepstrum = np.fft.irfft(log_spectrum)

    quefrency = np.arange(len(cepstrum)) / fs
    return quefrency, np.abs(cepstrum)

firmware/common/dsp/kaltech_dsp.c:1210–1321  ::  kaltech_cepstrum_extended_f32void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
    float nyq_mag = fabsf(kal_fft_work_pack[1]);
    log_mag_packed[0] = logf(dc_mag  > 1e-20f ? dc_mag  : 1e-20f);
    log_mag_packed[1] = logf(nyq_mag > 1e-20f ? nyq_mag : 1e-20f);
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2*k], im = kal_fft_work_pack[2*k + 1];
        float mag = sqrtf(re*re + im*im);
        log_mag_packed[2*k]     = logf(mag > 1e-20f ? mag : 1e-20f);
        log_mag_packed[2*k + 1] = 0.0f;
    }

    arm_rfft_fast_f32(&S, log_mag_packed, cepstrum, 1);

    /* Peak search over defect-period quefrency band [0.002 s, 0.1 s] —
     * defect frequencies 10–500 Hz. Matches features.py:942-946 mask
     * (quefrency >= 0.002) & (quefrency <= 0.1). Without this mask, the
     * argmax lands in the spectral-envelope region (k < 24 at fs=12000)
     * which is not a defect-period peak. Citation: Randall, "Frequency
     * Analysis" (Wiley 2011) Ch. 8 — bound by min/max defect period. */
    const float MIN_QUEF_S = 0.002f;
    const float MAX_QUEF_S = 0.1f;
    size_t lo = (size_t)((MIN_QUEF_S * fs) + 0.999999f);   /* ceil */
    size_t hi = (size_t)(MAX_QUEF_S * fs);                  /* floor */
    if (hi >= n / 2) hi = n / 2 - 1;
    if (lo > hi) {
        /* Mask empty (e.g. very short window). Outputs already zero from memset. */
        return;
    }
    /* Initialize peak to first masked value to match np.argmax tie-break:
     * if every value is identical, np.argmax returns the first index. */
    float peak = fabsf(cepstrum[lo]);
    size_t argmax = lo;
    for (size_t k = lo + 1; k <= hi; k++) {
        float a = fabsf(cepstrum[k]);
        if (a > peak) { peak = a; argmax = k; }   /* strict > matches np.argmax */
    }
    out->peak_magnitude   = peak;
    out->peak_quefrency_s = (float)argmax / fs;
    out->peak_freq_hz     = argmax > 0 ? fs / (float)argmax : 0.0f;

    /* Defect match: a bearing-impact cepstrum has peaks at the IMPACT PERIOD
     * (1/BPFO) AND its integer multiples (2/BPFO, 3/BPFO, ...). The original
     * implementation only matched the fundamental cep_freq vs defect freq
     * within ±5% — physically valid but very narrow. On shaft-dominated
     * signals the cepstrum peak lands at 1/shaft and never matches BPFO/
     * BPFI/BSF/FTF, returning 0 every record.
     *
     * Robust check (still matches Python features.py:967-975 on the
     * fundamental case): compare peak_quefrency × defect_freq against the
     * nearest integer K ∈ [1, 5]. If |Q·F - K| < 0.10 (10% tolerance on
# … 32 more lines truncated …

v5/lib/features_v5.py:554–596  ::  compute_spectral_kurtosisdef compute_spectral_kurtosis(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    window_size: int = 256,
    overlap: int = 192,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute Spectral Kurtosis via STFT (Randall Ch. 9, Antoni 2006).

    SK(f) = <|X(f)|^4> / <|X(f)|^2>^2 - 2

    High SK at a frequency → impulsive/transient content (bearing impacts).
    Low SK → stationary content (shaft rotation, noise).

    Use SK to identify the optimal frequency band for envelope demodulation.

    Convention / baseline note
    --------------------------
    Returns Antoni (2006) MSSP 20(2):282-307 eq. 6 baseline:
        SK = E[|X|^4] / E[|X|^2]^2 - 2.
    The -2 term is the complex-circular-Gaussian baseline. We compute SK
    on magnitude spectra (np.abs(rfft) upstream — power = |X|^2 of those
    magnitudes), so a real-Gaussian signal yields SK_baseline ≈ -1 rather
    than 0. This is a deliberate convention choice: we use SK for
    ORDERING bands (kurtogram band search) where the monotonic behaviour
    is unchanged. Absolute SK values reported as features should be
    interpreted relative to this baseline, not as Antoni's normalised SK.

    Returns:
        (frequencies, sk_values) — frequency axis and spectral kurtosis per bin
    """
    f, _t, Zxx = stft(signal, fs=fs, nperseg=window_size, noverlap=overlap)
    power = np.abs(Zxx) ** 2

    # SK = E[|X|^4] / E[|X|^2]^2 - 2
    mean_p2 = np.mean(power ** 2, axis=1)
    mean_p = np.mean(power, axis=1)

    sk = np.zeros_like(f)
    nonzero = mean_p > 1e-20
    sk[nonzero] = mean_p2[nonzero] / (mean_p[nonzero] ** 2) - 2.0

    return f, sk

firmware/common/dsp/kaltech_dsp.c:1544–1608  ::  kaltech_spectral_kurtosis_fixed_f32void kaltech_spectral_kurtosis_fixed_f32(const float *x, size_t n, float fs,
                                          int win, int overlap,
                                          float *sk_max, float *sk_mean) {
    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;
    for (int k = 0; k <= half; k++) {
        float freq = (float)k * fs / (float)win;
        if (freq <= 50.0f) continue;   /* match features.py f_sk > 50 */
        float mp = m_p[k] * inv, mp2 = m_p2[k] * inv;
        if (mp < 1e-20f) continue;
        float sk = mp2 / (mp * mp) - 2.0f;
        if (sk > peak) peak = sk;
        sum += sk; n_valid++;
    }
    if (n_valid > 0) {
        *sk_max  = peak;
        *sk_mean = (float)(sum / n_valid);
    }
}

v5/lib/features_v5.py:554–596  ::  compute_spectral_kurtosisdef compute_spectral_kurtosis(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    window_size: int = 256,
    overlap: int = 192,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute Spectral Kurtosis via STFT (Randall Ch. 9, Antoni 2006).

    SK(f) = <|X(f)|^4> / <|X(f)|^2>^2 - 2

    High SK at a frequency → impulsive/transient content (bearing impacts).
    Low SK → stationary content (shaft rotation, noise).

    Use SK to identify the optimal frequency band for envelope demodulation.

    Convention / baseline note
    --------------------------
    Returns Antoni (2006) MSSP 20(2):282-307 eq. 6 baseline:
        SK = E[|X|^4] / E[|X|^2]^2 - 2.
    The -2 term is the complex-circular-Gaussian baseline. We compute SK
    on magnitude spectra (np.abs(rfft) upstream — power = |X|^2 of those
    magnitudes), so a real-Gaussian signal yields SK_baseline ≈ -1 rather
    than 0. This is a deliberate convention choice: we use SK for
    ORDERING bands (kurtogram band search) where the monotonic behaviour
    is unchanged. Absolute SK values reported as features should be
    interpreted relative to this baseline, not as Antoni's normalised SK.

    Returns:
        (frequencies, sk_values) — frequency axis and spectral kurtosis per bin
    """
    f, _t, Zxx = stft(signal, fs=fs, nperseg=window_size, noverlap=overlap)
    power = np.abs(Zxx) ** 2

    # SK = E[|X|^4] / E[|X|^2]^2 - 2
    mean_p2 = np.mean(power ** 2, axis=1)
    mean_p = np.mean(power, axis=1)

    sk = np.zeros_like(f)
    nonzero = mean_p > 1e-20
    sk[nonzero] = mean_p2[nonzero] / (mean_p[nonzero] ** 2) - 2.0

    return f, sk

firmware/common/dsp/kaltech_dsp.c:1544–1608  ::  kaltech_spectral_kurtosis_fixed_f32void kaltech_spectral_kurtosis_fixed_f32(const float *x, size_t n, float fs,
                                          int win, int overlap,
                                          float *sk_max, float *sk_mean) {
    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;
    for (int k = 0; k <= half; k++) {
        float freq = (float)k * fs / (float)win;
        if (freq <= 50.0f) continue;   /* match features.py f_sk > 50 */
        float mp = m_p[k] * inv, mp2 = m_p2[k] * inv;
        if (mp < 1e-20f) continue;
        float sk = mp2 / (mp * mp) - 2.0f;
        if (sk > peak) peak = sk;
        sum += sk; n_valid++;
    }
    if (n_valid > 0) {
        *sk_max  = peak;
        *sk_mean = (float)(sum / n_valid);
    }
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:404–436  ::  kaltech_kurtogram_f32void kaltech_kurtogram_f32(const float *x, size_t n, float fs,
                           kaltech_kurtogram_t *out) {
    out->center_freq = 0.0f;
    out->bandwidth   = 0.0f;
    out->max_sk      = -1e30f;
    out->band_low    = 50.0f;
    out->band_high   = fs * 0.5f - 50.0f;

    const int wins[] = {64, 128, 256, 512};
    const int n_levels = 4;

    for (int L = 0; L < n_levels; L++) {
        int win = wins[L];
        if (win > (int)n / 4) break;

        float peak_sk, peak_freq;
        if (!scan_one_level(x, (int)n, win, fs, 0, 0, &peak_sk, &peak_freq)) continue;

        if (peak_sk > out->max_sk) {
            out->max_sk      = peak_sk;
            out->center_freq = peak_freq;
            out->bandwidth   = fs / (float)win;
        }
    }

    float half_bw = out->bandwidth * 0.5f;
    float lo = out->center_freq - half_bw;
    float hi = out->center_freq + half_bw;
    if (lo < 50.0f) lo = 50.0f;
    if (hi > fs * 0.5f - 50.0f) hi = fs * 0.5f - 50.0f;
    out->band_low  = lo;
    out->band_high = hi;
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:404–436  ::  kaltech_kurtogram_f32void kaltech_kurtogram_f32(const float *x, size_t n, float fs,
                           kaltech_kurtogram_t *out) {
    out->center_freq = 0.0f;
    out->bandwidth   = 0.0f;
    out->max_sk      = -1e30f;
    out->band_low    = 50.0f;
    out->band_high   = fs * 0.5f - 50.0f;

    const int wins[] = {64, 128, 256, 512};
    const int n_levels = 4;

    for (int L = 0; L < n_levels; L++) {
        int win = wins[L];
        if (win > (int)n / 4) break;

        float peak_sk, peak_freq;
        if (!scan_one_level(x, (int)n, win, fs, 0, 0, &peak_sk, &peak_freq)) continue;

        if (peak_sk > out->max_sk) {
            out->max_sk      = peak_sk;
            out->center_freq = peak_freq;
            out->bandwidth   = fs / (float)win;
        }
    }

    float half_bw = out->bandwidth * 0.5f;
    float lo = out->center_freq - half_bw;
    float hi = out->center_freq + half_bw;
    if (lo < 50.0f) lo = 50.0f;
    if (hi > fs * 0.5f - 50.0f) hi = fs * 0.5f - 50.0f;
    out->band_low  = lo;
    out->band_high = hi;
}

v5/lib/features_v5.py:660–673  ::  find_optimal_demod_banddef find_optimal_demod_band(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    n_levels: int = 3,
) -> dict[str, float]:
    """DEPRECATED alias for `stft_sk_band_search`.

    Kept for backward compatibility with existing callers (extract_features
    integration, parity tests, dashboard). The original name overstated
    the algorithm as full kurtogram; in fact we use a level-only STFT-SK
    sweep, not Antoni's 1/3-binary-tree decomposition. New code should
    call `stft_sk_band_search` directly. See its docstring for details.
    """
    return stft_sk_band_search(signal, fs=fs, n_levels=n_levels)

firmware/common/dsp/kaltech_dsp.c:404–436  ::  kaltech_kurtogram_f32void kaltech_kurtogram_f32(const float *x, size_t n, float fs,
                           kaltech_kurtogram_t *out) {
    out->center_freq = 0.0f;
    out->bandwidth   = 0.0f;
    out->max_sk      = -1e30f;
    out->band_low    = 50.0f;
    out->band_high   = fs * 0.5f - 50.0f;

    const int wins[] = {64, 128, 256, 512};
    const int n_levels = 4;

    for (int L = 0; L < n_levels; L++) {
        int win = wins[L];
        if (win > (int)n / 4) break;

        float peak_sk, peak_freq;
        if (!scan_one_level(x, (int)n, win, fs, 0, 0, &peak_sk, &peak_freq)) continue;

        if (peak_sk > out->max_sk) {
            out->max_sk      = peak_sk;
            out->center_freq = peak_freq;
            out->bandwidth   = fs / (float)win;
        }
    }

    float half_bw = out->bandwidth * 0.5f;
    float lo = out->center_freq - half_bw;
    float hi = out->center_freq + half_bw;
    if (lo < 50.0f) lo = 50.0f;
    if (hi > fs * 0.5f - 50.0f) hi = fs * 0.5f - 50.0f;
    out->band_low  = lo;
    out->band_high = hi;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1611–1658  ::  kaltech_order_features_f32float kaltech_order_features_f32(const float *mag, size_t n, float fs,
                                 float shaft_freq, float bpfo_o, float bpfi_o,
                                 float bsf_o, float ftf_o,
                                 float *out) {
    for (int i = 0; i < 18; i++) out[i] = 0.0f;
    if (shaft_freq <= 0.0f || n == 0) return 0.0f;

    const float max_order = 20.0f;
    const float bw = 0.15f;
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;

    float dom_mag = 0.0f;
    float dom_order = 0.0f;
    double subsync = 0.0;

    for (size_t k = 1; k <= half; k++) {
        float freq = (float)k * fs_per_n;
        float order = freq / shaft_freq;
        if (order > max_order) break;
        float m = mag[k];
        float p = m * m;

        for (int h = 1; h <= 10; h++) {
            if (fabsf(order - (float)h) <= bw) out[h - 1] += p;
        }
        if (bpfo_o > 0 && fabsf(order - bpfo_o) <= bw) out[10] += p;
        if (bpfi_o > 0 && fabsf(order - bpfi_o) <= bw) out[11] += p;
        if (bsf_o  > 0 && fabsf(order - bsf_o ) <= bw) out[12] += p;
        if (ftf_o  > 0 && fabsf(order - ftf_o ) <= bw) out[13] += p;
        if (bpfo_o > 0) {
            if (fabsf(order - (bpfo_o - 1.0f)) <= bw) out[14] += p;
            if (fabsf(order - (bpfo_o + 1.0f)) <= bw) out[14] += p;
        }
        if (bpfi_o > 0) {
            if (fabsf(order - (bpfi_o - 1.0f)) <= bw) out[15] += p;
            if (fabsf(order - (bpfi_o + 1.0f)) <= bw) out[15] += p;
        }
        if (order > 0.5f && m > dom_mag) { dom_mag = m; dom_order = order; }
        if (order > 0.1f && order < 0.95f) subsync += (double)p;
    }
    out[16] = dom_order;
    float e1 = out[0], e2 = out[1];
    float ratio = e1 / (e2 + 1e-8f);
    if (ratio > 1000.0f) ratio = 1000.0f;
    out[17] = ratio;
    return (float)subsync;
}

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.h:95–95  ::  kaltech_per_axis_feats_t::bpfo_order                                 float bpfo_order, float bpfi_order,

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.h:95–95  ::  kaltech_per_axis_feats_t::bpfo_order                                 float bpfo_order, float bpfi_order,

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.h:96–96  ::  kaltech_per_axis_feats_t::bsf_order                                 float bsf_order,  float ftf_order,

v5/lib/features_v5.py:1232–1334  ::  extract_order_featuresdef extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

    defect_orders = {
        "bpfo_order": defect_freqs["bpfo"] / shaft_freq,
        "bpfi_order": defect_freqs["bpfi"] / shaft_freq,
        "bsf_order": defect_freqs["bsf"] / shaft_freq,
        "ftf_order": defect_freqs["ftf"] / shaft_freq,
    }

    # Energy at defect orders (±0.15 order bandwidth)
    bw = 0.15
    for name, order_val in defect_orders.items():
        feat_name = f"order_energy_{name}"  # e.g. order_energy_bpfo_order
        mask_d = np.abs(orders_trim - order_val) <= bw
        order_energies[feat_name] = float(np.sum(mags_trim[mask_d] ** 2))

    # Sideband detection: check for modulation sidebands around defect orders
    # Sidebands at defect_order ± 1 indicate distributed faults
    for defect_name in ["bpfo", "bpfi"]:
        center_order = defect_orders[f"{defect_name}_order"]
        lower_sb = center_order - 1.0
        upper_sb = center_order + 1.0
        mask_lower = np.abs(orders_trim - lower_sb) <= bw
        mask_upper = np.abs(orders_trim - upper_sb) <= bw
        sb_energy = float(np.sum(mags_trim[mask_lower] ** 2) + np.sum(mags_trim[mask_upper] ** 2))
# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.h:96–96  ::  kaltech_per_axis_feats_t::bsf_order                                 float bsf_order,  float ftf_order,

v5/lib/features_v5.py:476–522  ::  tachless_rpm_featuresdef tachless_rpm_features(
    signal: np.ndarray,
    fs: int,
    approximate_rpm: float,
) -> dict[str, float]:
    """V5 helper: tachless on-edge shaft rotation rate estimation (Claims 18-19).

    Wraps v5.lib.tachless_cot.tachless_cot and returns 4 features per axis:
      rpm_estimate_hz   — tachless estimate of average shaft frequency (Hz)
      rpm_drift_pct     — sigma_pp peak-to-peak variability fraction (×100 for %)
      rpm_is_steady     — 1.0 if sigma_pp <= 5%, else 0.0
      rpm_confidence    — 0.0-1.0 quality score for the estimate

    Semantic states (consumer reads `rpm_confidence` to distinguish):
      - approximate_rpm <= 0      → all zeros (no RPM provided)
      - tachless_cot raises       → all zeros (computation failed)
      - tachless_cot degenerate   → omega_bar=0.0, confidence=0.0 (no shaft signal)
      - tachless_cot valid        → real values, confidence > 0.0

    When training KTnet V5: treat `rpm_confidence < 0.05` as "rpm unreliable" —
    the value of rpm_estimate_hz then becomes uninformative regardless of state.
    """
    out = {
        "rpm_estimate_hz": 0.0,
        "rpm_drift_pct": 0.0,
        "rpm_is_steady": 0.0,
        "rpm_confidence": 0.0,
    }
    if approximate_rpm <= 0:
        return out
    try:
        result = tachless_cot(signal, float(fs), approximate_rpm=float(approximate_rpm))
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out

firmware/common/dsp/tachless_cot.c:137–293  ::  kaltech_tachless_cot_featuresvoid kaltech_tachless_cot_features(
    const float *signal, size_t n, float fs, float approximate_rpm_hz,
    float *rpm_estimate_hz, float *rpm_drift_pct,
    float *rpm_is_steady,   float *rpm_confidence) {

    /* SENTINEL: always touch every output pointer FIRST. Per
     * ~/.claude/rules/parity-porting.md: "empty result must be a sentinel,
     * not a zero" — consumers distinguish "computed = 0" from "failed to
     * compute" via rpm_confidence==0. */
    if (rpm_estimate_hz) *rpm_estimate_hz = 0.0f;
    if (rpm_drift_pct)   *rpm_drift_pct   = 0.0f;
    if (rpm_is_steady)   *rpm_is_steady   = 0.0f;
    if (rpm_confidence)  *rpm_confidence  = 0.0f;

    /* Refuse to compute when the Python reference would also refuse
     * (ValueError → tachless_rpm_features returns all zeros). */
    if (!signal) return;
    if (approximate_rpm_hz <= 0.0f) return;
    if (fs <= 0.0f) return;
    /* Python check: n >= sub_window + hop (the tightened bound after the
     * 2026-05-15 fix to accept 2176-4095 samples). */
    if (n < (size_t)(KAL_COT_SUB_WIN + KAL_COT_HOP)) return;

    cot_init_hann();

    /* Hann window energy (Σ w²). Used as RFFT magnitude normaliser to match
     * Python: spectrum = |rfft(windowed)| / win_energy. */
    float win_energy = 0.0f;
    for (int i = 0; i < KAL_COT_SUB_WIN; i++) {
        win_energy += kal_cot_hann[i] * kal_cot_hann[i];
    }
    if (win_energy < 1.0e-20f) return;

    /* Slice plan: num_slices = (n - SUB) / HOP + 1. Cap at MAX_SLICES. */
    size_t num_slices_full = (n - (size_t)KAL_COT_SUB_WIN) / (size_t)KAL_COT_HOP + 1;
    if (num_slices_full < 2) return;     /* Python also refuses */
    int num_slices = (num_slices_full > (size_t)KAL_COT_MAX_SLICES)
                     ? KAL_COT_MAX_SLICES
                     : (int)num_slices_full;

    /* Search band — Python: f_target/60 → already passed in as Hz, so use
     * approximate_rpm_hz directly. NOTE: caller passes shaft_hz (i.e. Hz),
     * NOT raw RPM. The function name field says "approximate_rpm_hz" to
     * make the unit explicit (mirroring features_v5.py:tachless_rpm_features
     * which converts approximate_rpm via /60.0 before calling tachless_cot;
     * we shift that conversion to the caller). */
    float f_target = approximate_rpm_hz;
    float f_lo = KAL_COT_FREQ_LO_FRAC * f_target;
    float f_hi = KAL_COT_FREQ_HI_FRAC * f_target;
    const float nyquist = 0.5f * fs;
    if (f_hi > nyquist - 1.0f) f_hi = nyquist - 1.0f;
    if (f_lo < 0.0f) f_lo = 0.0f;
    if (f_lo >= f_hi) return;            /* degenerate band */

    /* Pre-compute search-band bin indices (constant across slices). */
    const float df_hz = fs / (float)KAL_COT_SUB_WIN;        /* bin spacing */
    int k_lo = (int)ceilf (f_lo / df_hz);
    int k_hi = (int)floorf(f_hi / df_hz);
    if (k_lo < 0) k_lo = 0;
    if (k_hi > KAL_COT_HALF - 1) k_hi = KAL_COT_HALF - 1;
    if (k_lo > k_hi) return;

    /* CMSIS rfft instance — initialise once per call (cheap, but could be
     * hoisted to module scope if profiling shows overhead). */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)KAL_COT_SUB_WIN) != ARM_MATH_SUCCESS) {
        return;
    }

    /* Continuity seed: Python uses prev_f = f_target on the very first slice.
     * Without this, the first slice can lock onto a stronger 2× harmonic
     * (common on unbalanced rotors) and stay stuck via continuity. */
    float prev_f = f_target;

    const float inv_win_energy = 1.0f / win_energy;

    for (int s = 0; s < num_slices; s++) {
        size_t start = (size_t)s * (size_t)KAL_COT_HOP;

        /* 1. Windowed copy (in float32). */
# … 77 more lines truncated …

v5/lib/features_v5.py:476–522  ::  tachless_rpm_featuresdef tachless_rpm_features(
    signal: np.ndarray,
    fs: int,
    approximate_rpm: float,
) -> dict[str, float]:
    """V5 helper: tachless on-edge shaft rotation rate estimation (Claims 18-19).

    Wraps v5.lib.tachless_cot.tachless_cot and returns 4 features per axis:
      rpm_estimate_hz   — tachless estimate of average shaft frequency (Hz)
      rpm_drift_pct     — sigma_pp peak-to-peak variability fraction (×100 for %)
      rpm_is_steady     — 1.0 if sigma_pp <= 5%, else 0.0
      rpm_confidence    — 0.0-1.0 quality score for the estimate

    Semantic states (consumer reads `rpm_confidence` to distinguish):
      - approximate_rpm <= 0      → all zeros (no RPM provided)
      - tachless_cot raises       → all zeros (computation failed)
      - tachless_cot degenerate   → omega_bar=0.0, confidence=0.0 (no shaft signal)
      - tachless_cot valid        → real values, confidence > 0.0

    When training KTnet V5: treat `rpm_confidence < 0.05` as "rpm unreliable" —
    the value of rpm_estimate_hz then becomes uninformative regardless of state.
    """
    out = {
        "rpm_estimate_hz": 0.0,
        "rpm_drift_pct": 0.0,
        "rpm_is_steady": 0.0,
        "rpm_confidence": 0.0,
    }
    if approximate_rpm <= 0:
        return out
    try:
        result = tachless_cot(signal, float(fs), approximate_rpm=float(approximate_rpm))
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out

firmware/common/dsp/tachless_cot.c:137–293  ::  kaltech_tachless_cot_featuresvoid kaltech_tachless_cot_features(
    const float *signal, size_t n, float fs, float approximate_rpm_hz,
    float *rpm_estimate_hz, float *rpm_drift_pct,
    float *rpm_is_steady,   float *rpm_confidence) {

    /* SENTINEL: always touch every output pointer FIRST. Per
     * ~/.claude/rules/parity-porting.md: "empty result must be a sentinel,
     * not a zero" — consumers distinguish "computed = 0" from "failed to
     * compute" via rpm_confidence==0. */
    if (rpm_estimate_hz) *rpm_estimate_hz = 0.0f;
    if (rpm_drift_pct)   *rpm_drift_pct   = 0.0f;
    if (rpm_is_steady)   *rpm_is_steady   = 0.0f;
    if (rpm_confidence)  *rpm_confidence  = 0.0f;

    /* Refuse to compute when the Python reference would also refuse
     * (ValueError → tachless_rpm_features returns all zeros). */
    if (!signal) return;
    if (approximate_rpm_hz <= 0.0f) return;
    if (fs <= 0.0f) return;
    /* Python check: n >= sub_window + hop (the tightened bound after the
     * 2026-05-15 fix to accept 2176-4095 samples). */
    if (n < (size_t)(KAL_COT_SUB_WIN + KAL_COT_HOP)) return;

    cot_init_hann();

    /* Hann window energy (Σ w²). Used as RFFT magnitude normaliser to match
     * Python: spectrum = |rfft(windowed)| / win_energy. */
    float win_energy = 0.0f;
    for (int i = 0; i < KAL_COT_SUB_WIN; i++) {
        win_energy += kal_cot_hann[i] * kal_cot_hann[i];
    }
    if (win_energy < 1.0e-20f) return;

    /* Slice plan: num_slices = (n - SUB) / HOP + 1. Cap at MAX_SLICES. */
    size_t num_slices_full = (n - (size_t)KAL_COT_SUB_WIN) / (size_t)KAL_COT_HOP + 1;
    if (num_slices_full < 2) return;     /* Python also refuses */
    int num_slices = (num_slices_full > (size_t)KAL_COT_MAX_SLICES)
                     ? KAL_COT_MAX_SLICES
                     : (int)num_slices_full;

    /* Search band — Python: f_target/60 → already passed in as Hz, so use
     * approximate_rpm_hz directly. NOTE: caller passes shaft_hz (i.e. Hz),
     * NOT raw RPM. The function name field says "approximate_rpm_hz" to
     * make the unit explicit (mirroring features_v5.py:tachless_rpm_features
     * which converts approximate_rpm via /60.0 before calling tachless_cot;
     * we shift that conversion to the caller). */
    float f_target = approximate_rpm_hz;
    float f_lo = KAL_COT_FREQ_LO_FRAC * f_target;
    float f_hi = KAL_COT_FREQ_HI_FRAC * f_target;
    const float nyquist = 0.5f * fs;
    if (f_hi > nyquist - 1.0f) f_hi = nyquist - 1.0f;
    if (f_lo < 0.0f) f_lo = 0.0f;
    if (f_lo >= f_hi) return;            /* degenerate band */

    /* Pre-compute search-band bin indices (constant across slices). */
    const float df_hz = fs / (float)KAL_COT_SUB_WIN;        /* bin spacing */
    int k_lo = (int)ceilf (f_lo / df_hz);
    int k_hi = (int)floorf(f_hi / df_hz);
    if (k_lo < 0) k_lo = 0;
    if (k_hi > KAL_COT_HALF - 1) k_hi = KAL_COT_HALF - 1;
    if (k_lo > k_hi) return;

    /* CMSIS rfft instance — initialise once per call (cheap, but could be
     * hoisted to module scope if profiling shows overhead). */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)KAL_COT_SUB_WIN) != ARM_MATH_SUCCESS) {
        return;
    }

    /* Continuity seed: Python uses prev_f = f_target on the very first slice.
     * Without this, the first slice can lock onto a stronger 2× harmonic
     * (common on unbalanced rotors) and stay stuck via continuity. */
    float prev_f = f_target;

    const float inv_win_energy = 1.0f / win_energy;

    for (int s = 0; s < num_slices; s++) {
        size_t start = (size_t)s * (size_t)KAL_COT_HOP;

        /* 1. Windowed copy (in float32). */
# … 77 more lines truncated …

v5/lib/features_v5.py:476–522  ::  tachless_rpm_featuresdef tachless_rpm_features(
    signal: np.ndarray,
    fs: int,
    approximate_rpm: float,
) -> dict[str, float]:
    """V5 helper: tachless on-edge shaft rotation rate estimation (Claims 18-19).

    Wraps v5.lib.tachless_cot.tachless_cot and returns 4 features per axis:
      rpm_estimate_hz   — tachless estimate of average shaft frequency (Hz)
      rpm_drift_pct     — sigma_pp peak-to-peak variability fraction (×100 for %)
      rpm_is_steady     — 1.0 if sigma_pp <= 5%, else 0.0
      rpm_confidence    — 0.0-1.0 quality score for the estimate

    Semantic states (consumer reads `rpm_confidence` to distinguish):
      - approximate_rpm <= 0      → all zeros (no RPM provided)
      - tachless_cot raises       → all zeros (computation failed)
      - tachless_cot degenerate   → omega_bar=0.0, confidence=0.0 (no shaft signal)
      - tachless_cot valid        → real values, confidence > 0.0

    When training KTnet V5: treat `rpm_confidence < 0.05` as "rpm unreliable" —
    the value of rpm_estimate_hz then becomes uninformative regardless of state.
    """
    out = {
        "rpm_estimate_hz": 0.0,
        "rpm_drift_pct": 0.0,
        "rpm_is_steady": 0.0,
        "rpm_confidence": 0.0,
    }
    if approximate_rpm <= 0:
        return out
    try:
        result = tachless_cot(signal, float(fs), approximate_rpm=float(approximate_rpm))
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out

firmware/common/dsp/tachless_cot.c:137–293  ::  kaltech_tachless_cot_featuresvoid kaltech_tachless_cot_features(
    const float *signal, size_t n, float fs, float approximate_rpm_hz,
    float *rpm_estimate_hz, float *rpm_drift_pct,
    float *rpm_is_steady,   float *rpm_confidence) {

    /* SENTINEL: always touch every output pointer FIRST. Per
     * ~/.claude/rules/parity-porting.md: "empty result must be a sentinel,
     * not a zero" — consumers distinguish "computed = 0" from "failed to
     * compute" via rpm_confidence==0. */
    if (rpm_estimate_hz) *rpm_estimate_hz = 0.0f;
    if (rpm_drift_pct)   *rpm_drift_pct   = 0.0f;
    if (rpm_is_steady)   *rpm_is_steady   = 0.0f;
    if (rpm_confidence)  *rpm_confidence  = 0.0f;

    /* Refuse to compute when the Python reference would also refuse
     * (ValueError → tachless_rpm_features returns all zeros). */
    if (!signal) return;
    if (approximate_rpm_hz <= 0.0f) return;
    if (fs <= 0.0f) return;
    /* Python check: n >= sub_window + hop (the tightened bound after the
     * 2026-05-15 fix to accept 2176-4095 samples). */
    if (n < (size_t)(KAL_COT_SUB_WIN + KAL_COT_HOP)) return;

    cot_init_hann();

    /* Hann window energy (Σ w²). Used as RFFT magnitude normaliser to match
     * Python: spectrum = |rfft(windowed)| / win_energy. */
    float win_energy = 0.0f;
    for (int i = 0; i < KAL_COT_SUB_WIN; i++) {
        win_energy += kal_cot_hann[i] * kal_cot_hann[i];
    }
    if (win_energy < 1.0e-20f) return;

    /* Slice plan: num_slices = (n - SUB) / HOP + 1. Cap at MAX_SLICES. */
    size_t num_slices_full = (n - (size_t)KAL_COT_SUB_WIN) / (size_t)KAL_COT_HOP + 1;
    if (num_slices_full < 2) return;     /* Python also refuses */
    int num_slices = (num_slices_full > (size_t)KAL_COT_MAX_SLICES)
                     ? KAL_COT_MAX_SLICES
                     : (int)num_slices_full;

    /* Search band — Python: f_target/60 → already passed in as Hz, so use
     * approximate_rpm_hz directly. NOTE: caller passes shaft_hz (i.e. Hz),
     * NOT raw RPM. The function name field says "approximate_rpm_hz" to
     * make the unit explicit (mirroring features_v5.py:tachless_rpm_features
     * which converts approximate_rpm via /60.0 before calling tachless_cot;
     * we shift that conversion to the caller). */
    float f_target = approximate_rpm_hz;
    float f_lo = KAL_COT_FREQ_LO_FRAC * f_target;
    float f_hi = KAL_COT_FREQ_HI_FRAC * f_target;
    const float nyquist = 0.5f * fs;
    if (f_hi > nyquist - 1.0f) f_hi = nyquist - 1.0f;
    if (f_lo < 0.0f) f_lo = 0.0f;
    if (f_lo >= f_hi) return;            /* degenerate band */

    /* Pre-compute search-band bin indices (constant across slices). */
    const float df_hz = fs / (float)KAL_COT_SUB_WIN;        /* bin spacing */
    int k_lo = (int)ceilf (f_lo / df_hz);
    int k_hi = (int)floorf(f_hi / df_hz);
    if (k_lo < 0) k_lo = 0;
    if (k_hi > KAL_COT_HALF - 1) k_hi = KAL_COT_HALF - 1;
    if (k_lo > k_hi) return;

    /* CMSIS rfft instance — initialise once per call (cheap, but could be
     * hoisted to module scope if profiling shows overhead). */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)KAL_COT_SUB_WIN) != ARM_MATH_SUCCESS) {
        return;
    }

    /* Continuity seed: Python uses prev_f = f_target on the very first slice.
     * Without this, the first slice can lock onto a stronger 2× harmonic
     * (common on unbalanced rotors) and stay stuck via continuity. */
    float prev_f = f_target;

    const float inv_win_energy = 1.0f / win_energy;

    for (int s = 0; s < num_slices; s++) {
        size_t start = (size_t)s * (size_t)KAL_COT_HOP;

        /* 1. Windowed copy (in float32). */
# … 77 more lines truncated …

v5/lib/features_v5.py:476–522  ::  tachless_rpm_featuresdef tachless_rpm_features(
    signal: np.ndarray,
    fs: int,
    approximate_rpm: float,
) -> dict[str, float]:
    """V5 helper: tachless on-edge shaft rotation rate estimation (Claims 18-19).

    Wraps v5.lib.tachless_cot.tachless_cot and returns 4 features per axis:
      rpm_estimate_hz   — tachless estimate of average shaft frequency (Hz)
      rpm_drift_pct     — sigma_pp peak-to-peak variability fraction (×100 for %)
      rpm_is_steady     — 1.0 if sigma_pp <= 5%, else 0.0
      rpm_confidence    — 0.0-1.0 quality score for the estimate

    Semantic states (consumer reads `rpm_confidence` to distinguish):
      - approximate_rpm <= 0      → all zeros (no RPM provided)
      - tachless_cot raises       → all zeros (computation failed)
      - tachless_cot degenerate   → omega_bar=0.0, confidence=0.0 (no shaft signal)
      - tachless_cot valid        → real values, confidence > 0.0

    When training KTnet V5: treat `rpm_confidence < 0.05` as "rpm unreliable" —
    the value of rpm_estimate_hz then becomes uninformative regardless of state.
    """
    out = {
        "rpm_estimate_hz": 0.0,
        "rpm_drift_pct": 0.0,
        "rpm_is_steady": 0.0,
        "rpm_confidence": 0.0,
    }
    if approximate_rpm <= 0:
        return out
    try:
        result = tachless_cot(signal, float(fs), approximate_rpm=float(approximate_rpm))
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out

firmware/common/dsp/tachless_cot.c:137–293  ::  kaltech_tachless_cot_featuresvoid kaltech_tachless_cot_features(
    const float *signal, size_t n, float fs, float approximate_rpm_hz,
    float *rpm_estimate_hz, float *rpm_drift_pct,
    float *rpm_is_steady,   float *rpm_confidence) {

    /* SENTINEL: always touch every output pointer FIRST. Per
     * ~/.claude/rules/parity-porting.md: "empty result must be a sentinel,
     * not a zero" — consumers distinguish "computed = 0" from "failed to
     * compute" via rpm_confidence==0. */
    if (rpm_estimate_hz) *rpm_estimate_hz = 0.0f;
    if (rpm_drift_pct)   *rpm_drift_pct   = 0.0f;
    if (rpm_is_steady)   *rpm_is_steady   = 0.0f;
    if (rpm_confidence)  *rpm_confidence  = 0.0f;

    /* Refuse to compute when the Python reference would also refuse
     * (ValueError → tachless_rpm_features returns all zeros). */
    if (!signal) return;
    if (approximate_rpm_hz <= 0.0f) return;
    if (fs <= 0.0f) return;
    /* Python check: n >= sub_window + hop (the tightened bound after the
     * 2026-05-15 fix to accept 2176-4095 samples). */
    if (n < (size_t)(KAL_COT_SUB_WIN + KAL_COT_HOP)) return;

    cot_init_hann();

    /* Hann window energy (Σ w²). Used as RFFT magnitude normaliser to match
     * Python: spectrum = |rfft(windowed)| / win_energy. */
    float win_energy = 0.0f;
    for (int i = 0; i < KAL_COT_SUB_WIN; i++) {
        win_energy += kal_cot_hann[i] * kal_cot_hann[i];
    }
    if (win_energy < 1.0e-20f) return;

    /* Slice plan: num_slices = (n - SUB) / HOP + 1. Cap at MAX_SLICES. */
    size_t num_slices_full = (n - (size_t)KAL_COT_SUB_WIN) / (size_t)KAL_COT_HOP + 1;
    if (num_slices_full < 2) return;     /* Python also refuses */
    int num_slices = (num_slices_full > (size_t)KAL_COT_MAX_SLICES)
                     ? KAL_COT_MAX_SLICES
                     : (int)num_slices_full;

    /* Search band — Python: f_target/60 → already passed in as Hz, so use
     * approximate_rpm_hz directly. NOTE: caller passes shaft_hz (i.e. Hz),
     * NOT raw RPM. The function name field says "approximate_rpm_hz" to
     * make the unit explicit (mirroring features_v5.py:tachless_rpm_features
     * which converts approximate_rpm via /60.0 before calling tachless_cot;
     * we shift that conversion to the caller). */
    float f_target = approximate_rpm_hz;
    float f_lo = KAL_COT_FREQ_LO_FRAC * f_target;
    float f_hi = KAL_COT_FREQ_HI_FRAC * f_target;
    const float nyquist = 0.5f * fs;
    if (f_hi > nyquist - 1.0f) f_hi = nyquist - 1.0f;
    if (f_lo < 0.0f) f_lo = 0.0f;
    if (f_lo >= f_hi) return;            /* degenerate band */

    /* Pre-compute search-band bin indices (constant across slices). */
    const float df_hz = fs / (float)KAL_COT_SUB_WIN;        /* bin spacing */
    int k_lo = (int)ceilf (f_lo / df_hz);
    int k_hi = (int)floorf(f_hi / df_hz);
    if (k_lo < 0) k_lo = 0;
    if (k_hi > KAL_COT_HALF - 1) k_hi = KAL_COT_HALF - 1;
    if (k_lo > k_hi) return;

    /* CMSIS rfft instance — initialise once per call (cheap, but could be
     * hoisted to module scope if profiling shows overhead). */
    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)KAL_COT_SUB_WIN) != ARM_MATH_SUCCESS) {
        return;
    }

    /* Continuity seed: Python uses prev_f = f_target on the very first slice.
     * Without this, the first slice can lock onto a stronger 2× harmonic
     * (common on unbalanced rotors) and stay stuck via continuity. */
    float prev_f = f_target;

    const float inv_win_energy = 1.0f / win_energy;

    for (int s = 0; s < num_slices; s++) {
        size_t start = (size_t)s * (size_t)KAL_COT_HOP;

        /* 1. Windowed copy (in float32). */
# … 77 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1476–1663  ::  compute_cross_axis_featuresdef compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
    result["rms_vector_magnitude"] = float(np.sqrt(rms_x**2 + rms_y**2 + rms_z**2))
    result["rms_ratio_xy"] = rms_x / rms_y
    result["rms_ratio_xz"] = rms_x / rms_z

    # ── Crest factor max across axes ──
    def _crest(s: np.ndarray) -> float:
        r = np.sqrt(np.mean(s**2))
        return float(np.max(np.abs(s)) / (r + eps))

    result["crest_max_axis"] = max(_crest(seg_x), _crest(seg_y), _crest(seg_z))

    # ── Energy anisotropy ──
    rms_vals = [rms_x, rms_y, rms_z]
    result["energy_anisotropy"] = max(rms_vals) / min(rms_vals)

    # ── Coherence computation (Welch-averaged, per Bendat & Piersol) ──
    # Single-block MSC is always 1.0 — must average over multiple segments.
    # Use scipy.signal.coherence which implements Welch's method internally.
    from scipy.signal import coherence as _scipy_coherence
    n = len(seg_x)
    # nperseg=256 with 2048-sample window gives ~15 averages (enough for meaningful MSC)
    _coh_nperseg = min(256, n // 4) if n >= 64 else n
    _coh_noverlap = _coh_nperseg // 2
# … 108 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1825–1916  ::  kaltech_cross_axis_featuresvoid kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
    /* RMS vector magnitude + ratios */
    const float eps = 1e-10f;
    float rx = axis_rms(x, n) + eps;
    float ry = axis_rms(y, n) + eps;
    float rz = axis_rms(z, n) + eps;
    out->rms_vector_magnitude = sqrtf(rx*rx + ry*ry + rz*rz);
    out->rms_ratio_xy = rx / ry;
    out->rms_ratio_xz = rx / rz;
    /* Crest max axis */
    float cx = axis_crest(x, n), cy = axis_crest(y, n), cz = axis_crest(z, n);
    out->crest_max_axis = cx > cy ? (cx > cz ? cx : cz) : (cy > cz ? cy : cz);
    /* Energy anisotropy */
    float rmax = rx > ry ? (rx > rz ? rx : rz) : (ry > rz ? ry : rz);
    float rmin = rx < ry ? (rx < rz ? rx : rz) : (ry < rz ? ry : rz);
    out->energy_anisotropy = rmax / rmin;

    /* Welch MSC for coherence (requires FFT — only if N >= nperseg) */
    static float msc_xy[KAL_WELCH_HALF], msc_xz[KAL_WELCH_HALF], msc_yz[KAL_WELCH_HALF];
    welch_msc(x, y, n, fs, msc_xy, NULL);
    welch_msc(x, z, n, fs, msc_xz, NULL);
    welch_msc(y, z, n, fs, msc_yz, NULL);
    out->coherence_mean = (band_mean(msc_xy, KAL_WELCH_HALF)
                         + band_mean(msc_xz, KAL_WELCH_HALF)
                         + band_mean(msc_yz, KAL_WELCH_HALF)) / 3.0f;
    if (shaft_hz > 0) {
        out->coherence_at_shaft_xy = msc_at_freq(msc_xy, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_xz = msc_at_freq(msc_xz, shaft_hz, 5.0f, fs);
        out->coherence_at_shaft_yz = msc_at_freq(msc_yz, shaft_hz, 5.0f, fs);
    }
    if (bpfo > 0 && bpfo < fs/2) {
        out->coherence_at_bpfo_xy = msc_at_freq(msc_xy, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_xz = msc_at_freq(msc_xz, bpfo, 5.0f, fs);
        out->coherence_at_bpfo_yz = msc_at_freq(msc_yz, bpfo, 5.0f, fs);
    }
    if (bpfi > 0 && bpfi < fs/2) {
        out->coherence_at_bpfi_xy = msc_at_freq(msc_xy, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_xz = msc_at_freq(msc_xz, bpfi, 5.0f, fs);
        out->coherence_at_bpfi_yz = msc_at_freq(msc_yz, bpfi, 5.0f, fs);
    }
    if (bsf > 0 && bsf < fs/2) {
        out->coherence_at_bsf_xy = msc_at_freq(msc_xy, bsf, 5.0f, fs);
        out->coherence_at_bsf_xz = msc_at_freq(msc_xz, bsf, 5.0f, fs);
        out->coherence_at_bsf_yz = msc_at_freq(msc_yz, bsf, 5.0f, fs);
    }
    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
# … 12 more lines truncated …

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1702–1913  ::  extract_ultrasonic_featuresdef extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
        _us_log.warning("Signal is all zeros — sensor may be disconnected")

    # --- Filter each band ONCE, reuse for RMS + sub-window analysis ---
    def _filter_band(low_hz: float, high_hz: float) -> np.ndarray | None:
        if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
            return None
        lo = max(low_hz / nyq, 0.001)
        hi = min(high_hz / nyq, 0.999)
        if hi <= lo:
            return None
        b, a = butter(4, [lo, hi], btype="band")
        return filtfilt(b, a, us_signal)

    filt_overall = _filter_band(20000, 80000)
    filt_bearing = _filter_band(25000, 40000)
    filt_leak = _filter_band(38000, 42000)
    filt_electrical = _filter_band(30000, 50000)

    # --- Band-limited RMS values (from pre-filtered signals) ---
    def _rms_of(arr: np.ndarray | None) -> float:
        if arr is None:
            return 0.0
        return float(np.sqrt(np.mean(arr ** 2)))
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1930–1971  ::  kaltech_ultrasonic_featuresvoid kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);
    out->us_rms_leak        = band_rms(mag, n, fs, 40000.0f, 100000.0f);
    out->us_rms_electrical  = band_rms(mag, n, fs, 80000.0f, 100000.0f);
    out->us_rms_bearing_band    = out->us_rms_bearing;
    out->us_rms_leak_band       = out->us_rms_leak;
    out->us_rms_electrical_band = out->us_rms_electrical;
    out->us_max_rms = fmaxf(out->us_rms_bearing, fmaxf(out->us_rms_leak, out->us_rms_electrical));
    out->us_max_rms_100ms = out->us_max_rms;   /* single-window approximation */

    /* Spectral flatness on full spectrum */
    kaltech_spec_feats_t sf;
    kaltech_spec_features(mag, n, fs, &sf);
    out->us_spectral_flatness = sf.spectral_flatness;
    out->us_dominant_freq     = sf.dominant_freq_hz;

    /* Baseline delta in dB against first-N-scan bearing RMS */
    if (baseline_bearing_rms > 0.01f) {
        out->us_baseline_delta_dB = 20.0f * log10f(out->us_rms_bearing / baseline_bearing_rms);
    }

    /* Steadiness: 1 - normalized std / mean across a sliding window.
     * Single-window approximation: us_is_steady = 1 if crest < 2.5 else 0. */
    out->us_is_steady = out->us_crest_factor < 2.5f ? 1.0f : 0.0f;
    out->us_steadiness = 1.0f / (out->us_crest_factor + 1e-3f);
}

v5/lib/features_v5.py:1920–1996  ::  extract_temperature_featuresdef extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

    # Temperature-vibration correlation (Claim 10)
    # Concurrent positive correlation indicates friction-driven degradation
    # as distinguished from environmental temperature confounders
    temp_vibration_correlation = 0.0
    if (temp_history and rms_history
            and len(temp_history) >= 3 and len(rms_history) >= 3):
        min_len = min(len(temp_history), len(rms_history))
        t_arr = np.array(temp_history[-min_len:], dtype=np.float64)
        r_arr = np.array(rms_history[-min_len:], dtype=np.float64)
        if np.std(t_arr) > 1e-10 and np.std(r_arr) > 1e-10:
            temp_vibration_correlation = float(np.corrcoef(t_arr, r_arr)[0, 1])
            if not math.isfinite(temp_vibration_correlation):
                temp_vibration_correlation = 0.0

    return {
        "surface_temp_c": float(surface_temp_c),
        "ambient_temp_c": float(ambient_temp_c),
        "delta_t": float(delta_t),
        "humidity_pct": float(humidity_pct),
        "temp_rate_of_rise": float(temp_rate_of_rise),
        "temp_vibration_correlation": float(temp_vibration_correlation),
    }

firmware/common/dsp/kaltech_dsp.c:1974–2011  ::  kaltech_temperature_featuresvoid kaltech_temperature_features(float surface_c, float ambient_c, float humidity,
                                  const float *temp_history, const float *vib_rms_history,
                                  size_t hist_len,
                                  kaltech_temperature_feats_t *out) {
    memset(out, 0, sizeof(*out));
    out->surface_temp_c = surface_c;
    out->ambient_temp_c = ambient_c;
    out->delta_t        = surface_c - ambient_c;
    out->humidity_pct   = humidity;

    /* Rate of rise: (last - first) / (N-1) × sample_period.
     * Caller provides samples at known interval; here we express in °C per sample. */
    if (temp_history && hist_len >= 2) {
        out->temp_rate_of_rise = (temp_history[hist_len - 1] - temp_history[0])
                                / (float)(hist_len - 1);
    }

    /* Pearson correlation between temp and vibration RMS histories */
    if (temp_history && vib_rms_history && hist_len >= 3) {
        out->temp_vibration_correlation = pearson_corr(temp_history, vib_rms_history, hist_len);
    }

    /* Bearing thermal state machine (universal — see kaltech_dsp.h header
     * for the multi-standard threshold rationale: ISO 14224, API 670,
     * UIC 518 / EN 15437, SKF/CSI/B&K bearing CM guidance).
     *   excess = surface - ambient
     *   ≤ 50 °C  → NORMAL
     *   ≤ 90 °C  → WARN
     *   >  90 °C → ALARM
     * Independent rate-of-rise rule: > 2 °C/sample at typical 1-min sampling
     * (≈ 2 °C/min) elevates state by one tier (capped at ALARM). */
    out->temp_excess_above_ambient = out->delta_t;
    int state = KAL_THERMAL_NORMAL;
    if (out->temp_excess_above_ambient > 90.0f)      state = KAL_THERMAL_ALARM;
    else if (out->temp_excess_above_ambient > 50.0f) state = KAL_THERMAL_WARN;
    if (out->temp_rate_of_rise > 2.0f && state < KAL_THERMAL_ALARM) state++;
    out->hot_box_state = state;
}

v5/lib/features_v5.py:1920–1996  ::  extract_temperature_featuresdef extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

    # Temperature-vibration correlation (Claim 10)
    # Concurrent positive correlation indicates friction-driven degradation
    # as distinguished from environmental temperature confounders
    temp_vibration_correlation = 0.0
    if (temp_history and rms_history
            and len(temp_history) >= 3 and len(rms_history) >= 3):
        min_len = min(len(temp_history), len(rms_history))
        t_arr = np.array(temp_history[-min_len:], dtype=np.float64)
        r_arr = np.array(rms_history[-min_len:], dtype=np.float64)
        if np.std(t_arr) > 1e-10 and np.std(r_arr) > 1e-10:
            temp_vibration_correlation = float(np.corrcoef(t_arr, r_arr)[0, 1])
            if not math.isfinite(temp_vibration_correlation):
                temp_vibration_correlation = 0.0

    return {
        "surface_temp_c": float(surface_temp_c),
        "ambient_temp_c": float(ambient_temp_c),
        "delta_t": float(delta_t),
        "humidity_pct": float(humidity_pct),
        "temp_rate_of_rise": float(temp_rate_of_rise),
        "temp_vibration_correlation": float(temp_vibration_correlation),
    }

firmware/common/dsp/kaltech_dsp.c:1974–2011  ::  kaltech_temperature_featuresvoid kaltech_temperature_features(float surface_c, float ambient_c, float humidity,
                                  const float *temp_history, const float *vib_rms_history,
                                  size_t hist_len,
                                  kaltech_temperature_feats_t *out) {
    memset(out, 0, sizeof(*out));
    out->surface_temp_c = surface_c;
    out->ambient_temp_c = ambient_c;
    out->delta_t        = surface_c - ambient_c;
    out->humidity_pct   = humidity;

    /* Rate of rise: (last - first) / (N-1) × sample_period.
     * Caller provides samples at known interval; here we express in °C per sample. */
    if (temp_history && hist_len >= 2) {
        out->temp_rate_of_rise = (temp_history[hist_len - 1] - temp_history[0])
                                / (float)(hist_len - 1);
    }

    /* Pearson correlation between temp and vibration RMS histories */
    if (temp_history && vib_rms_history && hist_len >= 3) {
        out->temp_vibration_correlation = pearson_corr(temp_history, vib_rms_history, hist_len);
    }

    /* Bearing thermal state machine (universal — see kaltech_dsp.h header
     * for the multi-standard threshold rationale: ISO 14224, API 670,
     * UIC 518 / EN 15437, SKF/CSI/B&K bearing CM guidance).
     *   excess = surface - ambient
     *   ≤ 50 °C  → NORMAL
     *   ≤ 90 °C  → WARN
     *   >  90 °C → ALARM
     * Independent rate-of-rise rule: > 2 °C/sample at typical 1-min sampling
     * (≈ 2 °C/min) elevates state by one tier (capped at ALARM). */
    out->temp_excess_above_ambient = out->delta_t;
    int state = KAL_THERMAL_NORMAL;
    if (out->temp_excess_above_ambient > 90.0f)      state = KAL_THERMAL_ALARM;
    else if (out->temp_excess_above_ambient > 50.0f) state = KAL_THERMAL_WARN;
    if (out->temp_rate_of_rise > 2.0f && state < KAL_THERMAL_ALARM) state++;
    out->hot_box_state = state;
}

v5/lib/features_v5.py:1920–1996  ::  extract_temperature_featuresdef extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

    # Temperature-vibration correlation (Claim 10)
    # Concurrent positive correlation indicates friction-driven degradation
    # as distinguished from environmental temperature confounders
    temp_vibration_correlation = 0.0
    if (temp_history and rms_history
            and len(temp_history) >= 3 and len(rms_history) >= 3):
        min_len = min(len(temp_history), len(rms_history))
        t_arr = np.array(temp_history[-min_len:], dtype=np.float64)
        r_arr = np.array(rms_history[-min_len:], dtype=np.float64)
        if np.std(t_arr) > 1e-10 and np.std(r_arr) > 1e-10:
            temp_vibration_correlation = float(np.corrcoef(t_arr, r_arr)[0, 1])
            if not math.isfinite(temp_vibration_correlation):
                temp_vibration_correlation = 0.0

    return {
        "surface_temp_c": float(surface_temp_c),
        "ambient_temp_c": float(ambient_temp_c),
        "delta_t": float(delta_t),
        "humidity_pct": float(humidity_pct),
        "temp_rate_of_rise": float(temp_rate_of_rise),
        "temp_vibration_correlation": float(temp_vibration_correlation),
    }

firmware/common/dsp/kaltech_dsp.c:1974–2011  ::  kaltech_temperature_featuresvoid kaltech_temperature_features(float surface_c, float ambient_c, float humidity,
                                  const float *temp_history, const float *vib_rms_history,
                                  size_t hist_len,
                                  kaltech_temperature_feats_t *out) {
    memset(out, 0, sizeof(*out));
    out->surface_temp_c = surface_c;
    out->ambient_temp_c = ambient_c;
    out->delta_t        = surface_c - ambient_c;
    out->humidity_pct   = humidity;

    /* Rate of rise: (last - first) / (N-1) × sample_period.
     * Caller provides samples at known interval; here we express in °C per sample. */
    if (temp_history && hist_len >= 2) {
        out->temp_rate_of_rise = (temp_history[hist_len - 1] - temp_history[0])
                                / (float)(hist_len - 1);
    }

    /* Pearson correlation between temp and vibration RMS histories */
    if (temp_history && vib_rms_history && hist_len >= 3) {
        out->temp_vibration_correlation = pearson_corr(temp_history, vib_rms_history, hist_len);
    }

    /* Bearing thermal state machine (universal — see kaltech_dsp.h header
     * for the multi-standard threshold rationale: ISO 14224, API 670,
     * UIC 518 / EN 15437, SKF/CSI/B&K bearing CM guidance).
     *   excess = surface - ambient
     *   ≤ 50 °C  → NORMAL
     *   ≤ 90 °C  → WARN
     *   >  90 °C → ALARM
     * Independent rate-of-rise rule: > 2 °C/sample at typical 1-min sampling
     * (≈ 2 °C/min) elevates state by one tier (capped at ALARM). */
    out->temp_excess_above_ambient = out->delta_t;
    int state = KAL_THERMAL_NORMAL;
    if (out->temp_excess_above_ambient > 90.0f)      state = KAL_THERMAL_ALARM;
    else if (out->temp_excess_above_ambient > 50.0f) state = KAL_THERMAL_WARN;
    if (out->temp_rate_of_rise > 2.0f && state < KAL_THERMAL_ALARM) state++;
    out->hot_box_state = state;
}

v5/lib/features_v5.py:1920–1996  ::  extract_temperature_featuresdef extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

    # Temperature-vibration correlation (Claim 10)
    # Concurrent positive correlation indicates friction-driven degradation
    # as distinguished from environmental temperature confounders
    temp_vibration_correlation = 0.0
    if (temp_history and rms_history
            and len(temp_history) >= 3 and len(rms_history) >= 3):
        min_len = min(len(temp_history), len(rms_history))
        t_arr = np.array(temp_history[-min_len:], dtype=np.float64)
        r_arr = np.array(rms_history[-min_len:], dtype=np.float64)
        if np.std(t_arr) > 1e-10 and np.std(r_arr) > 1e-10:
            temp_vibration_correlation = float(np.corrcoef(t_arr, r_arr)[0, 1])
            if not math.isfinite(temp_vibration_correlation):
                temp_vibration_correlation = 0.0

    return {
        "surface_temp_c": float(surface_temp_c),
        "ambient_temp_c": float(ambient_temp_c),
        "delta_t": float(delta_t),
        "humidity_pct": float(humidity_pct),
        "temp_rate_of_rise": float(temp_rate_of_rise),
        "temp_vibration_correlation": float(temp_vibration_correlation),
    }

firmware/common/dsp/kaltech_dsp.c:1974–2011  ::  kaltech_temperature_featuresvoid kaltech_temperature_features(float surface_c, float ambient_c, float humidity,
                                  const float *temp_history, const float *vib_rms_history,
                                  size_t hist_len,
                                  kaltech_temperature_feats_t *out) {
    memset(out, 0, sizeof(*out));
    out->surface_temp_c = surface_c;
    out->ambient_temp_c = ambient_c;
    out->delta_t        = surface_c - ambient_c;
    out->humidity_pct   = humidity;

    /* Rate of rise: (last - first) / (N-1) × sample_period.
     * Caller provides samples at known interval; here we express in °C per sample. */
    if (temp_history && hist_len >= 2) {
        out->temp_rate_of_rise = (temp_history[hist_len - 1] - temp_history[0])
                                / (float)(hist_len - 1);
    }

    /* Pearson correlation between temp and vibration RMS histories */
    if (temp_history && vib_rms_history && hist_len >= 3) {
        out->temp_vibration_correlation = pearson_corr(temp_history, vib_rms_history, hist_len);
    }

    /* Bearing thermal state machine (universal — see kaltech_dsp.h header
     * for the multi-standard threshold rationale: ISO 14224, API 670,
     * UIC 518 / EN 15437, SKF/CSI/B&K bearing CM guidance).
     *   excess = surface - ambient
     *   ≤ 50 °C  → NORMAL
     *   ≤ 90 °C  → WARN
     *   >  90 °C → ALARM
     * Independent rate-of-rise rule: > 2 °C/sample at typical 1-min sampling
     * (≈ 2 °C/min) elevates state by one tier (capped at ALARM). */
    out->temp_excess_above_ambient = out->delta_t;
    int state = KAL_THERMAL_NORMAL;
    if (out->temp_excess_above_ambient > 90.0f)      state = KAL_THERMAL_ALARM;
    else if (out->temp_excess_above_ambient > 50.0f) state = KAL_THERMAL_WARN;
    if (out->temp_rate_of_rise > 2.0f && state < KAL_THERMAL_ALARM) state++;
    out->hot_box_state = state;
}

v5/lib/features_v5.py:1920–1996  ::  extract_temperature_featuresdef extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

    # Temperature-vibration correlation (Claim 10)
    # Concurrent positive correlation indicates friction-driven degradation
    # as distinguished from environmental temperature confounders
    temp_vibration_correlation = 0.0
    if (temp_history and rms_history
            and len(temp_history) >= 3 and len(rms_history) >= 3):
        min_len = min(len(temp_history), len(rms_history))
        t_arr = np.array(temp_history[-min_len:], dtype=np.float64)
        r_arr = np.array(rms_history[-min_len:], dtype=np.float64)
        if np.std(t_arr) > 1e-10 and np.std(r_arr) > 1e-10:
            temp_vibration_correlation = float(np.corrcoef(t_arr, r_arr)[0, 1])
            if not math.isfinite(temp_vibration_correlation):
                temp_vibration_correlation = 0.0

    return {
        "surface_temp_c": float(surface_temp_c),
        "ambient_temp_c": float(ambient_temp_c),
        "delta_t": float(delta_t),
        "humidity_pct": float(humidity_pct),
        "temp_rate_of_rise": float(temp_rate_of_rise),
        "temp_vibration_correlation": float(temp_vibration_correlation),
    }

firmware/common/dsp/kaltech_dsp.c:1974–2011  ::  kaltech_temperature_featuresvoid kaltech_temperature_features(float surface_c, float ambient_c, float humidity,
                                  const float *temp_history, const float *vib_rms_history,
                                  size_t hist_len,
                                  kaltech_temperature_feats_t *out) {
    memset(out, 0, sizeof(*out));
    out->surface_temp_c = surface_c;
    out->ambient_temp_c = ambient_c;
    out->delta_t        = surface_c - ambient_c;
    out->humidity_pct   = humidity;

    /* Rate of rise: (last - first) / (N-1) × sample_period.
     * Caller provides samples at known interval; here we express in °C per sample. */
    if (temp_history && hist_len >= 2) {
        out->temp_rate_of_rise = (temp_history[hist_len - 1] - temp_history[0])
                                / (float)(hist_len - 1);
    }

    /* Pearson correlation between temp and vibration RMS histories */
    if (temp_history && vib_rms_history && hist_len >= 3) {
        out->temp_vibration_correlation = pearson_corr(temp_history, vib_rms_history, hist_len);
    }

    /* Bearing thermal state machine (universal — see kaltech_dsp.h header
     * for the multi-standard threshold rationale: ISO 14224, API 670,
     * UIC 518 / EN 15437, SKF/CSI/B&K bearing CM guidance).
     *   excess = surface - ambient
     *   ≤ 50 °C  → NORMAL
     *   ≤ 90 °C  → WARN
     *   >  90 °C → ALARM
     * Independent rate-of-rise rule: > 2 °C/sample at typical 1-min sampling
     * (≈ 2 °C/min) elevates state by one tier (capped at ALARM). */
    out->temp_excess_above_ambient = out->delta_t;
    int state = KAL_THERMAL_NORMAL;
    if (out->temp_excess_above_ambient > 90.0f)      state = KAL_THERMAL_ALARM;
    else if (out->temp_excess_above_ambient > 50.0f) state = KAL_THERMAL_WARN;
    if (out->temp_rate_of_rise > 2.0f && state < KAL_THERMAL_ALARM) state++;
    out->hot_box_state = state;
}

v5/lib/features_v5.py:1920–1996  ::  extract_temperature_featuresdef extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

    # Temperature-vibration correlation (Claim 10)
    # Concurrent positive correlation indicates friction-driven degradation
    # as distinguished from environmental temperature confounders
    temp_vibration_correlation = 0.0
    if (temp_history and rms_history
            and len(temp_history) >= 3 and len(rms_history) >= 3):
        min_len = min(len(temp_history), len(rms_history))
        t_arr = np.array(temp_history[-min_len:], dtype=np.float64)
        r_arr = np.array(rms_history[-min_len:], dtype=np.float64)
        if np.std(t_arr) > 1e-10 and np.std(r_arr) > 1e-10:
            temp_vibration_correlation = float(np.corrcoef(t_arr, r_arr)[0, 1])
            if not math.isfinite(temp_vibration_correlation):
                temp_vibration_correlation = 0.0

    return {
        "surface_temp_c": float(surface_temp_c),
        "ambient_temp_c": float(ambient_temp_c),
        "delta_t": float(delta_t),
        "humidity_pct": float(humidity_pct),
        "temp_rate_of_rise": float(temp_rate_of_rise),
        "temp_vibration_correlation": float(temp_vibration_correlation),
    }

firmware/common/dsp/kaltech_dsp.c:1974–2011  ::  kaltech_temperature_featuresvoid kaltech_temperature_features(float surface_c, float ambient_c, float humidity,
                                  const float *temp_history, const float *vib_rms_history,
                                  size_t hist_len,
                                  kaltech_temperature_feats_t *out) {
    memset(out, 0, sizeof(*out));
    out->surface_temp_c = surface_c;
    out->ambient_temp_c = ambient_c;
    out->delta_t        = surface_c - ambient_c;
    out->humidity_pct   = humidity;

    /* Rate of rise: (last - first) / (N-1) × sample_period.
     * Caller provides samples at known interval; here we express in °C per sample. */
    if (temp_history && hist_len >= 2) {
        out->temp_rate_of_rise = (temp_history[hist_len - 1] - temp_history[0])
                                / (float)(hist_len - 1);
    }

    /* Pearson correlation between temp and vibration RMS histories */
    if (temp_history && vib_rms_history && hist_len >= 3) {
        out->temp_vibration_correlation = pearson_corr(temp_history, vib_rms_history, hist_len);
    }

    /* Bearing thermal state machine (universal — see kaltech_dsp.h header
     * for the multi-standard threshold rationale: ISO 14224, API 670,
     * UIC 518 / EN 15437, SKF/CSI/B&K bearing CM guidance).
     *   excess = surface - ambient
     *   ≤ 50 °C  → NORMAL
     *   ≤ 90 °C  → WARN
     *   >  90 °C → ALARM
     * Independent rate-of-rise rule: > 2 °C/sample at typical 1-min sampling
     * (≈ 2 °C/min) elevates state by one tier (capped at ALARM). */
    out->temp_excess_above_ambient = out->delta_t;
    int state = KAL_THERMAL_NORMAL;
    if (out->temp_excess_above_ambient > 90.0f)      state = KAL_THERMAL_ALARM;
    else if (out->temp_excess_above_ambient > 50.0f) state = KAL_THERMAL_WARN;
    if (out->temp_rate_of_rise > 2.0f && state < KAL_THERMAL_ALARM) state++;
    out->hot_box_state = state;
}