trueno 0.16.4

High-performance SIMD compute library with GPU support for matrix operations
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use super::*;

#[test]
fn test_gpu_leaky_relu_basic() {
    let Some(mut gpu) = get_shared_gpu() else {
        eprintln!("GPU not available, skipping test");
        return;
    };
    let input = vec![-3.0, -1.0, 0.0, 1.0, 3.0];
    let negative_slope = 0.01;

    let result = gpu.leaky_relu(&input, negative_slope);

    if let Ok(output) = result {
        // Expected: max(negative_slope * x, x)
        let expected = [-0.03, -0.01, 0.0, 1.0, 3.0];
        for (r, e) in output.iter().zip(expected.iter()) {
            assert!((r - e).abs() < 1e-4, "Leaky ReLU mismatch: got={}, expected={}", r, e);
        }
    } else {
        eprintln!("GPU leaky_relu failed: {:?}", result);
    }
}

#[test]
fn test_gpu_elu_basic() {
    let Some(mut gpu) = get_shared_gpu() else {
        eprintln!("GPU not available, skipping test");
        return;
    };
    let input = vec![-2.0, -1.0, 0.0, 1.0, 2.0];
    let alpha = 1.0;

    let result = gpu.elu(&input, alpha);

    if let Ok(output) = result {
        // Expected: x if x > 0, else alpha * (exp(x) - 1)
        for (i, (r, &x)) in output.iter().zip(input.iter()).enumerate() {
            let expected = if x > 0.0 { x } else { alpha * (x.exp() - 1.0) };
            assert!(
                (r - expected).abs() < 1e-3,
                "ELU mismatch at {}: got={}, expected={}",
                i,
                r,
                expected
            );
        }
    } else {
        eprintln!("GPU elu failed: {:?}", result);
    }
}

#[test]
fn test_gpu_tanh_basic() {
    let Some(mut gpu) = get_shared_gpu() else {
        eprintln!("GPU not available, skipping test");
        return;
    };
    let input = vec![-2.0, -1.0, 0.0, 1.0, 2.0];

    let result = gpu.tanh(&input);

    if let Ok(output) = result {
        for (r, &x) in output.iter().zip(input.iter()) {
            let expected = x.tanh();
            assert!((r - expected).abs() < 1e-4, "Tanh mismatch: got={}, expected={}", r, expected);
        }
    } else {
        eprintln!("GPU tanh failed: {:?}", result);
    }
}

#[test]
fn test_gpu_tanh_not_hardcoded() {
    // EXTREME TDD: Kill mutant that replaces return with Ok(vec![-1.0])
    let Some(mut gpu) = get_shared_gpu() else {
        eprintln!("GPU not available, skipping test");
        return;
    };
    let input = vec![1.0, 2.0, 3.0];

    let result = gpu.tanh(&input).expect("GPU tanh should succeed");

    // Kill mutant: verify result is NOT all -1.0 values
    assert_ne!(
        result,
        vec![-1.0, -1.0, -1.0],
        "GPU tanh returned hardcoded -1.0 values (mutant not killed)"
    );

    // Verify correct computation
    for (i, &x) in input.iter().enumerate() {
        let expected = x.tanh();
        assert!(
            (result[i] - expected).abs() < 1e-4,
            "tanh({}) = {} (expected {})",
            x,
            result[i],
            expected
        );
    }
}

#[test]
fn test_gpu_softmax_basic() {
    let Some(mut gpu) = get_shared_gpu() else {
        eprintln!("GPU not available, skipping test");
        return;
    };
    let input = vec![1.0, 2.0, 3.0, 4.0];

    let result = gpu.softmax(&input);

    if let Ok(output) = result {
        // Softmax should sum to 1
        let sum: f32 = output.iter().sum();
        assert!((sum - 1.0).abs() < 1e-3, "Softmax sum should be 1, got {}", sum);

        // All values should be positive
        for &v in &output {
            assert!(v > 0.0, "Softmax values should be positive");
        }

        // Later values should be larger (input is increasing)
        for i in 1..output.len() {
            assert!(
                output[i] > output[i - 1],
                "Softmax should preserve order for increasing input"
            );
        }
    } else {
        eprintln!("GPU softmax failed: {:?}", result);
    }
}

#[test]
fn test_gpu_log_softmax_basic() {
    let Some(mut gpu) = get_shared_gpu() else {
        eprintln!("GPU not available, skipping test");
        return;
    };
    let input = vec![1.0, 2.0, 3.0, 4.0];

    let result = gpu.log_softmax(&input);

    if let Ok(output) = result {
        // log_softmax values should all be negative (log of probability < 1)
        for &v in &output {
            assert!(v <= 0.0, "Log softmax values should be <= 0, got {}", v);
        }

        // exp(log_softmax) should sum to 1
        let exp_sum: f32 = output.iter().map(|x| x.exp()).sum();
        assert!((exp_sum - 1.0).abs() < 1e-3, "exp(log_softmax) should sum to 1, got {}", exp_sum);
    } else {
        eprintln!("GPU log_softmax failed: {:?}", result);
    }
}