trueno 0.17.3

High-performance SIMD compute library with GPU support for matrix 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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use super::super::super::super::*;
use proptest::prelude::*;

// ========================================================================
// Property tests for relu() - Rectified Linear Unit
// ========================================================================

proptest! {
    /// Property test: relu() produces non-negative outputs
    /// All outputs should be >= 0
    #[test]
    fn test_relu_non_negative(
        a in prop::collection::vec(-100.0f32..100.0, 1..100)
    ) {
        let va = Vector::from_slice(&a);
        let result = va.relu().unwrap();

        for &val in result.as_slice() {
            prop_assert!(
                val >= 0.0,
                "ReLU output {} should be non-negative",
                val
            );
        }
    }
}

proptest! {
    /// Property test: relu() preserves positive values
    /// For all x > 0, relu(x) = x
    #[test]
    fn test_relu_preserves_positive(
        a in prop::collection::vec(-100.0f32..100.0, 1..100)
    ) {
        let va = Vector::from_slice(&a);
        let result = va.relu().unwrap();

        for (i, &val) in a.iter().enumerate() {
            if val > 0.0 {
                prop_assert!(
                    (result.data[i] - val).abs() < 1e-6,
                    "ReLU should preserve positive value: {} became {}",
                    val, result.data[i]
                );
            }
        }
    }
}

proptest! {
    /// Property test: relu() is idempotent
    /// relu(relu(x)) = relu(x)
    #[test]
    fn test_relu_idempotent(
        a in prop::collection::vec(-100.0f32..100.0, 1..100)
    ) {
        let va = Vector::from_slice(&a);
        let relu1 = va.relu().unwrap();
        let relu2 = relu1.relu().unwrap();

        for (i, &orig_val) in a.iter().enumerate() {
            prop_assert!(
                (relu1.data[i] - relu2.data[i]).abs() < 1e-6,
                "ReLU should be idempotent: relu(relu({})) = {} != relu({}) = {}",
                orig_val, relu2.data[i], orig_val, relu1.data[i]
            );
        }
    }
}

// ========================================================================
// Property tests for sigmoid() - Logistic activation
// ========================================================================

proptest! {
    /// Property test: sigmoid() produces values in [0, 1]
    #[test]
    fn test_sigmoid_bounded(
        a in prop::collection::vec(-100.0f32..100.0, 1..100)
    ) {
        let va = Vector::from_slice(&a);
        let result = va.sigmoid().unwrap();

        for &val in result.as_slice() {
            prop_assert!(
                (0.0..=1.0).contains(&val),
                "Sigmoid output {} not in [0, 1]",
                val
            );
        }
    }
}

proptest! {
    /// Property test: sigmoid() symmetry: sigma(-x) = 1 - sigma(x)
    #[test]
    fn test_sigmoid_symmetry_property(
        a in prop::collection::vec(-50.0f32..50.0, 1..100)
    ) {
        let va = Vector::from_slice(&a);
        let sig_pos = va.sigmoid().unwrap();

        // Create negated vector
        let a_neg: Vec<f32> = a.iter().map(|&x| -x).collect();
        let va_neg = Vector::from_slice(&a_neg);
        let sig_neg = va_neg.sigmoid().unwrap();

        // sigma(-x) + sigma(x) should equal 1
        for (i, &val) in a.iter().enumerate() {
            let sum = sig_pos.data[i] + sig_neg.data[i];
            prop_assert!(
                (sum - 1.0).abs() < 1e-5,
                "Symmetry violated: sigma({}) + sigma({}) = {} + {} = {} != 1",
                val, -val, sig_pos.data[i], sig_neg.data[i], sum
            );
        }
    }
}

proptest! {
    /// Property test: sigmoid() is monotonically increasing
    /// If x < y, then sigma(x) < sigma(y)
    #[test]
    fn test_sigmoid_monotonic(
        a in prop::collection::vec(-50.0f32..50.0, 2..100)
    ) {
        let va = Vector::from_slice(&a);
        let result = va.sigmoid().unwrap();

        // Check all pairs for monotonicity
        for i in 0..a.len() {
            for j in 0..a.len() {
                if a[i] < a[j] {
                    prop_assert!(
                        result.data[i] < result.data[j] + 1e-6,
                        "Monotonicity violated: {} < {} but sigma({}) = {} >= sigma({}) = {}",
                        a[i], a[j], a[i], result.data[i], a[j], result.data[j]
                    );
                }
            }
        }
    }
}