microgemm 0.3.1

General matrix multiplication with custom configuration in Rust. Supports no_std and no_alloc environments.
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

mod arbitrary;
mod naive;

mod proptest_kernel;

use approx::{AbsDiffEq, RelativeEq};

pub use arbitrary::*;
pub use naive::naive_gemm;
pub use proptest_kernel::{proptest_kernel, ProptestKernelCfg};

pub fn assert_approx_eq<T>(left: impl AsRef<[T]>, right: impl AsRef<[T]>, eps: T)
where
    T: RelativeEq<T> + Copy + core::fmt::Debug + AbsDiffEq<Epsilon = T>,
{
    let left = left.as_ref();
    let right = right.as_ref();
    assert_eq!(left.len(), right.len());

    for (&l, &r) in left.iter().zip(right) {
        assert_relative_eq!(l, r, epsilon = eps);
    }
}

#[allow(dead_code)]
pub const fn is_release_build() -> bool {
    !is_debug_build()
}

#[allow(dead_code)]
pub const fn is_debug_build() -> bool {
    let mut debug = false;
    debug_assert!({
        debug = true;
        debug
    });
    debug
}

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

    #[test]
    fn test_eq() {
        let eps = f32::EPSILON;
        let x = [1., 2., 3.];
        let y = [x[0] + eps, x[1] + 3. * eps, x[2] + 2. * eps];
        assert_approx_eq(x, y, 4. * eps);
    }
    #[test]
    #[should_panic]
    fn test_ne() {
        let eps = f32::EPSILON;
        let x = [1., 2., 3.];
        let y = [x[0] + eps, x[1] + 3. * eps, x[2] + 2. * eps];
        assert_approx_eq(x, y, eps);
    }
}