helena 0.1.0

Core types and component interfaces for helena, a latent data-to-waveform generation platform.
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

use super::*;

#[test]
fn pure_levels_are_exact_endpoints() {
    let signal = NoiseLevel::pure_signal();
    assert_eq!(signal.signal(), 1.0);
    assert_eq!(signal.noise(), 0.0);
    let noise = NoiseLevel::pure_noise();
    assert_eq!(noise.signal(), 0.0);
    assert_eq!(noise.noise(), 1.0);

    let x0 = tensor([1, 3], vec![1.0, -2.0, 3.0]);
    let eps = tensor([1, 3], vec![0.5, 0.5, 0.5]);
    assert_eq!(signal.diffuse(&x0, &eps).unwrap(), x0);
    assert_eq!(noise.diffuse(&x0, &eps).unwrap(), eps);
}

#[test]
fn from_signal_variance_rejects_out_of_range() {
    for bad in [-0.1, 1.1, f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
        assert!(matches!(
            NoiseLevel::from_signal_variance(bad),
            Err(Error::Validation(_))
        ));
    }
}

#[test]
fn min_snr_gamma_rejects_non_positive_and_non_finite() {
    for bad in [0.0, -1.0, f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
        assert!(matches!(MinSnrGamma::new(bad), Err(Error::Validation(_))));
    }
    for good in [MinSnrGamma::DEFAULT, 1e-3, 1e6] {
        assert_eq!(MinSnrGamma::new(good).unwrap().get(), good);
    }
}

#[test]
fn velocity_min_snr_weight_vanishes_at_the_endpoints() {
    let clip = MinSnrGamma::new(MinSnrGamma::DEFAULT).unwrap();
    // gamma = 1 (no noise) and gamma = 0 (no signal) both carry zero weight.
    assert_eq!(NoiseLevel::pure_signal().velocity_min_snr_weight(clip), 0.0);
    assert_eq!(NoiseLevel::pure_noise().velocity_min_snr_weight(clip), 0.0);
}

#[test]
fn velocity_min_snr_weight_clips_in_the_two_regimes() {
    let clip = MinSnrGamma::new(5.0).unwrap();
    // Below the crossover gamma = clip / (1 + clip) = 5/6 the weight is gamma
    // (the low-SNR branch); above it the weight is clip * (1 - gamma).
    let low = NoiseLevel::from_signal_variance(0.5).unwrap();
    assert!((low.velocity_min_snr_weight(clip) - 0.5).abs() < 1e-6);
    let high = NoiseLevel::from_signal_variance(0.9).unwrap();
    assert!((high.velocity_min_snr_weight(clip) - 0.5).abs() < 1e-6);
    // At the crossover both branches meet at clip / (1 + clip) = 5/6.
    let cross = NoiseLevel::from_signal_variance(5.0 / 6.0).unwrap();
    assert!((cross.velocity_min_snr_weight(clip) - 5.0 / 6.0).abs() < 1e-6);
}