conspire 0.6.0

The Rust interface to conspire.
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

use crate::math::{Tensor, TensorArray, TensorRank0, TensorRank2, TensorRank2List};

fn get_array() -> [[[TensorRank0; 3]; 3]; 8] {
    [
        [[3.0, 0.0, 3.0], [4.0, 4.0, 1.0], [4.0, 0.0, 4.0]],
        [[3.0, 4.0, 0.0], [1.0, 3.0, 2.0], [4.0, 0.0, 2.0]],
        [[0.0, 1.0, 4.0], [3.0, 1.0, 4.0], [1.0, 0.0, 0.0]],
        [[4.0, 0.0, 1.0], [0.0, 4.0, 3.0], [1.0, 2.0, 2.0]],
        [[3.0, 3.0, 2.0], [4.0, 4.0, 4.0], [4.0, 1.0, 3.0]],
        [[1.0, 3.0, 1.0], [2.0, 2.0, 3.0], [0.0, 0.0, 3.0]],
        [[3.0, 3.0, 4.0], [4.0, 1.0, 2.0], [0.0, 3.0, 3.0]],
        [[3.0, 1.0, 0.0], [3.0, 0.0, 4.0], [0.0, 3.0, 3.0]],
    ]
}

fn get_tensor_rank_2_list() -> TensorRank2List<3, 1, 1, 8> {
    TensorRank2List::from(get_array())
}

#[test]
fn as_array() {
    get_tensor_rank_2_list()
        .as_array()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_2_entry, array_entry)| {
            tensor_rank_2_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_2_entry_i, array_entry_i)| {
                    tensor_rank_2_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_2_entry_ij, array_entry_ij)| {
                            assert_eq!(tensor_rank_2_entry_ij, array_entry_ij)
                        })
                },
            )
        });
}

#[test]
fn iter() {
    get_tensor_rank_2_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_2_entry, array_entry)| {
            tensor_rank_2_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_2_entry_i, array_entry_i)| {
                    tensor_rank_2_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_2_entry_ij, array_entry_ij)| {
                            assert_eq!(tensor_rank_2_entry_ij, array_entry_ij)
                        })
                },
            )
        });
}

#[test]
fn iter_mut() {
    get_tensor_rank_2_list()
        .iter_mut()
        .zip(get_array().iter_mut())
        .for_each(|(tensor_rank_2_entry, array_entry)| {
            tensor_rank_2_entry
                .iter_mut()
                .zip(array_entry.iter_mut())
                .for_each(|(tensor_rank_2_entry_i, array_entry_i)| {
                    tensor_rank_2_entry_i
                        .iter_mut()
                        .zip(array_entry_i.iter_mut())
                        .for_each(|(tensor_rank_2_entry_ij, array_entry_ij)| {
                            assert_eq!(tensor_rank_2_entry_ij, array_entry_ij)
                        })
                })
        });
}

#[test]
fn from() {
    get_tensor_rank_2_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_2_entry, array_entry)| {
            tensor_rank_2_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_2_entry_i, array_entry_i)| {
                    tensor_rank_2_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_2_entry_ij, array_entry_ij)| {
                            assert_eq!(tensor_rank_2_entry_ij, array_entry_ij)
                        })
                },
            )
        });
}

#[test]
fn size() {
    assert_eq!(
        std::mem::size_of::<TensorRank2List::<3, 1, 1, 8>>(),
        std::mem::size_of::<[TensorRank2::<3, 1, 1>; 8]>()
    )
}

#[test]
fn zero() {
    TensorRank2List::<3, 1, 1, 8>::zero()
        .iter()
        .for_each(|tensor_rank_2_entry| {
            tensor_rank_2_entry
                .iter()
                .for_each(|tensor_rank_2_entry_i| {
                    tensor_rank_2_entry_i
                        .iter()
                        .for_each(|tensor_rank_2_entry_ij| assert_eq!(tensor_rank_2_entry_ij, &0.0))
                })
        });
}