numeric 0.1.4

N-dimensional matrix class for Rust
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

macro_rules! add_impl {
    ($t:ty, $m:ident) => (
        mod $m {
            use numeric::Tensor;
            type T = Tensor<$t>;

            #[test]
            fn test_creation_ones_1() {
                let t1 = T::ones(&[4]);
                assert_eq!(t1.shape(), &[4]);
                assert_eq!(t1.data(), &vec![1.0, 1.0, 1.0, 1.0]);
            }

            #[test]
            fn test_creation_ones_2() {
                let t2 = T::ones(&[2, 1]);
                assert_eq!(t2.shape(), &[2, 1]);
                assert_eq!(t2.data(), &vec![1.0, 1.0]);
            }

            #[test]
            fn test_creation_ones_3() {
                let t3 = T::ones(&[2, 1, 3]);
                assert_eq!(t3.shape(), &[2, 1, 3]);
                assert_eq!(t3.data(), &vec![1.0, 1.0, 1.0, 1.0, 1.0, 1.0]);
            }

            #[test]
            fn test_creation_zeros_3() {
                let t3 = T::zeros(&[2, 1, 3]);
                assert_eq!(t3.shape(), &[2, 1, 3]);
                assert_eq!(t3.data(), &vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
            }

            #[test]
            fn test_creation_range() {
                let t1 = T::range(4);
                assert_eq!(t1.shape(), &[4]);
                assert_eq!(t1.data(), &vec![0.0, 1.0, 2.0, 3.0]);

                let t2 = T::range(0);
                assert_eq!(t2.shape(), &[0]);
                assert_eq!(t2.data().len(), 0);
            }

            #[test]
            fn test_partial_eq_1() {
                let t1 = T::new(vec![1.0, 2.0, 3.0, 10.0, 2.0, -3.0]).reshape(&[3, 2]);
                let t2 = T::new(vec![1.0, 2.0, 3.0, 10.0, 2.0, -3.0]).reshape(&[3, 2]);
                assert!(t1 == t2);
            }

            #[test]
            fn test_partial_eq_2() {
                let t1 = T::new(vec![1.0, 2.0, 3.0, 10.0, 2.0, -3.0]).reshape(&[3, 2]);
                let t2 = T::new(vec![1.0, 2.0, 3.0, 10.0, 2.0, -3.0]).reshape(&[2, 3]);
                let p = t1 != t2;
                assert!(p);
            }

            #[test]
            fn test_partial_eq_3() {
                let t1 = T::new(vec![1.0, 2.0, 3.0, 10.0, 2.0, -3.0]).reshape(&[3, 2]);
                let t2 = T::new(vec![1.0, 2.0, 3.0, 10.0, 3.0, -3.0]).reshape(&[3, 2]);
                assert!(t1 != t2);
            }
        }
    )
}

add_impl!(f32, float32);
add_impl!(f64, float64);