mousiki 0.2.1

Pure Rust Opus codec.
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

//! Floating-point correlation regulariser from `silk/float/regularize_correlations_FLP.c`.
//!
//! The helper adds a small noise term to each diagonal entry of the correlation
//! matrix and to the first element of the correlation vector. This mirrors the
//! stabilisation used before solving the normal equations in the SILK FLP
//! analysis path.

/// Adds `noise` to each diagonal entry of the `dim × dim` matrix `xx_matrix`
/// and to the first element of the correlation vector `xx_vector`.
///
/// Both containers must be large enough to cover the touched elements.
pub fn regularize_correlations_flp(
    xx_matrix: &mut [f32],
    xx_vector: &mut [f32],
    noise: f32,
    dim: usize,
) {
    assert!(
        xx_matrix.len() >= dim * dim,
        "matrix must provide room for a {dim}×{dim} layout"
    );
    assert!(
        !xx_vector.is_empty(),
        "correlation vector must contain at least one element"
    );

    for i in 0..dim {
        let idx = i * dim + i;
        xx_matrix[idx] += noise;
    }

    xx_vector[0] += noise;
}

#[cfg(test)]
mod tests {
    use super::regularize_correlations_flp;

    #[test]
    fn adds_noise_to_diagonal_and_vector() {
        let mut matrix = [
            10.0f32, 1.0, 2.0, //
            3.0, 20.0, 4.0, //
            5.0, 6.0, 30.0,
        ];
        let mut vector = [100.0f32, 200.0, 300.0];

        regularize_correlations_flp(&mut matrix, &mut vector, 0.25, 3);

        assert_eq!(
            matrix,
            [
                10.25, 1.0, 2.0, //
                3.0, 20.25, 4.0, //
                5.0, 6.0, 30.25,
            ]
        );
        assert_eq!(vector, [100.25, 200.0, 300.0]);
    }

    #[test]
    fn handles_zero_dimension_by_only_touching_vector() {
        let mut matrix = [1.0f32, 2.0, 3.0, 4.0];
        let mut vector = [0.0f32];

        regularize_correlations_flp(&mut matrix, &mut vector, 1.5, 0);

        assert_eq!(matrix, [1.0, 2.0, 3.0, 4.0]);
        assert_eq!(vector, [1.5]);
    }

    #[test]
    #[should_panic(expected = "matrix must provide room for a 4×4 layout")]
    fn panics_when_matrix_too_small() {
        let mut matrix = [0.0f32; 8]; // only 2x4 entries
        let mut vector = [0.0f32; 4];
        regularize_correlations_flp(&mut matrix, &mut vector, 0.1, 4);
    }

    #[test]
    #[should_panic(expected = "correlation vector must contain at least one element")]
    fn panics_when_vector_empty() {
        let mut matrix = [0.0f32; 1];
        let mut vector = [];
        regularize_correlations_flp(&mut matrix, &mut vector, 0.1, 1);
    }
}