sim-lib-numbers-signal 0.1.0

Deterministic transforms, autoregression, spectral estimation, and guarded signal operations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use super::*;

// conformance: Savitzky-Golay polynomial laws and Toeplitz diagnostics.

#[test]
fn savitzky_golay_preserves_fitted_polynomials() {
    let filter = savitzky_golay(SavitzkyGolaySpec {
        window_length: 7,
        polynomial_order: 3,
        ..SavitzkyGolaySpec::default()
    })
    .unwrap();
    let samples = (-10..=10)
        .map(|x| {
            let x = f64::from(x);
            2.0 - 0.5 * x + 0.25 * x * x - 0.125 * x * x * x
        })
        .collect::<Vec<_>>();
    let smoothed = apply_savitzky_golay(&samples, &filter, BoundaryMode::Symmetric).unwrap();
    for index in 3..samples.len() - 3 {
        assert!((smoothed[index] - samples[index]).abs() < 1e-9);
    }
}

#[test]
fn derivatives_include_factorial_and_physical_spacing() {
    let spacing = 0.25;
    let filter = savitzky_golay(SavitzkyGolaySpec {
        window_length: 7,
        polynomial_order: 3,
        derivative_order: 2,
        sample_spacing: spacing,
        ..SavitzkyGolaySpec::default()
    })
    .unwrap();
    let samples = (-10..=10)
        .map(|index| {
            let x = f64::from(index) * spacing;
            3.0 * x * x + 2.0 * x + 1.0
        })
        .collect::<Vec<_>>();
    let derivative = apply_savitzky_golay(&samples, &filter, BoundaryMode::Zero).unwrap();
    for value in &derivative[3..derivative.len() - 3] {
        assert!((*value - 6.0).abs() < 1e-9, "{value}");
    }
}

#[test]
fn toeplitz_solver_reports_pivots_and_residual() {
    let solution = solve_toeplitz(
        &[4.0, 1.0, 0.5],
        &[4.0, 2.0, -1.0],
        &[5.5, 6.0, 3.5],
        ToeplitzPlan::default(),
    )
    .unwrap();
    assert!((solution.values[0] - 1.0).abs() < 1e-12);
    assert!((solution.values[1] - 1.0).abs() < 1e-12);
    assert!((solution.values[2] - 0.5).abs() < 1e-12);
    assert!(solution.diagnostics.reciprocal_pivot_condition > 0.0);
    assert!(solution.diagnostics.residual_l2 < 1e-12);
}

#[test]
fn toeplitz_singularity_returns_threshold_diagnostics() {
    let error = solve_toeplitz(
        &[1.0, 1.0],
        &[1.0, 1.0],
        &[2.0, 2.0],
        ToeplitzPlan::default(),
    )
    .unwrap_err();
    assert!(matches!(
        error,
        SignalError::SingularSystem {
            operation: "Toeplitz",
            step: 1,
            pivot_magnitude,
            threshold,
        } if pivot_magnitude <= threshold
    ));
}

#[test]
fn smoothing_policies_fail_closed() {
    assert!(
        savitzky_golay(SavitzkyGolaySpec {
            window_length: 4,
            ..SavitzkyGolaySpec::default()
        })
        .is_err()
    );
    assert!(
        savitzky_golay(SavitzkyGolaySpec {
            derivative_order: 3,
            polynomial_order: 2,
            ..SavitzkyGolaySpec::default()
        })
        .is_err()
    );
    assert!(
        solve_toeplitz(
            &[1.0, 0.0],
            &[2.0, 0.0],
            &[1.0, 1.0],
            ToeplitzPlan::default(),
        )
        .is_err()
    );
}