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
111
112
113
114
115
116
117
118
119

use super::*;

// conformance: sampled interpolation shape, duplicate, and extrapolation policy.

fn plan(method: InterpolationMethod) -> InterpolationPlan {
    InterpolationPlan {
        method,
        ..InterpolationPlan::default()
    }
}

#[test]
fn linear_and_cubic_interpolants_preserve_affine_data() {
    let x = [0.0, 1.0, 2.5, 4.0];
    let y = x.map(|x| 2.0 * x - 1.0);
    let at = [0.25, 1.5, 3.75];
    for method in [InterpolationMethod::Linear, InterpolationMethod::Cubic] {
        let result = interpolate_samples(&x, &y, &at, plan(method)).unwrap();
        for (&coordinate, &value) in at.iter().zip(&result.values) {
            assert!((value - (2.0 * coordinate - 1.0)).abs() < 1e-10);
        }
    }
}

#[test]
fn monotone_cubic_does_not_overshoot_sample_intervals() {
    let interpolator = SampleInterpolator::new(
        &[0.0, 1.0, 2.0, 4.0],
        &[0.0, 1.0, 1.5, 3.0],
        plan(InterpolationMethod::Monotone),
    )
    .unwrap();
    let at = (0..=80)
        .map(|index| index as f64 / 20.0)
        .collect::<Vec<_>>();
    let values = interpolator.evaluate(&at).unwrap().values;
    assert!(values.windows(2).all(|pair| pair[0] <= pair[1]));
    assert!(values.iter().all(|value| (0.0..=3.0).contains(value)));
}

#[test]
fn duplicate_policies_are_explicit_and_reported() {
    let x = [0.0, 1.0, 1.0, 2.0];
    let y = [0.0, 1.0, 3.0, 4.0];
    assert!(matches!(
        SampleInterpolator::new(&x, &y, InterpolationPlan::default()),
        Err(SignalError::DuplicateCoordinate { index: 2, .. })
    ));
    let interpolator = SampleInterpolator::new(
        &x,
        &y,
        InterpolationPlan {
            method: InterpolationMethod::Linear,
            duplicates: DuplicateXPolicy::Average,
            extrapolation: ExtrapolationPolicy::Reject,
        },
    )
    .unwrap();
    let result = interpolator.evaluate(&[1.0]).unwrap();
    assert_eq!(result.values, vec![2.0]);
    assert_eq!(result.report.duplicates_resolved, 1);
    assert_eq!(result.report.unique_points, 3);
}

#[test]
fn extrapolation_rejects_clamps_or_continues_endpoint_secants() {
    let x = [0.0, 1.0, 2.0];
    let y = [0.0, 2.0, 3.0];
    assert!(matches!(
        interpolate_samples(&x, &y, &[-1.0], plan(InterpolationMethod::Linear)),
        Err(SignalError::OutOfDomain { index: 0, .. })
    ));
    let clamped = interpolate_samples(
        &x,
        &y,
        &[-1.0, 3.0],
        InterpolationPlan {
            method: InterpolationMethod::Monotone,
            duplicates: DuplicateXPolicy::Reject,
            extrapolation: ExtrapolationPolicy::Clamp,
        },
    )
    .unwrap();
    assert_eq!(clamped.values, vec![0.0, 3.0]);
    assert_eq!(clamped.report.extrapolated_points, 2);
    let extended = interpolate_samples(
        &x,
        &y,
        &[-1.0, 3.0],
        InterpolationPlan {
            method: InterpolationMethod::Cubic,
            duplicates: DuplicateXPolicy::Reject,
            extrapolation: ExtrapolationPolicy::Linear,
        },
    )
    .unwrap();
    assert_eq!(extended.values, vec![-2.0, 4.0]);
}

#[test]
fn interpolation_rejects_unsorted_and_non_finite_inputs() {
    assert!(
        SampleInterpolator::new(
            &[0.0, 2.0, 1.0],
            &[0.0, 1.0, 2.0],
            InterpolationPlan::default(),
        )
        .is_err()
    );
    assert!(
        interpolate_samples(
            &[0.0, 1.0],
            &[0.0, f64::NAN],
            &[0.5],
            InterpolationPlan::default(),
        )
        .is_err()
    );
}