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
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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

use crate::math::{Tensor, TensorArray, TensorRank0, TensorRank4, TensorRank4List};

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

fn get_tensor_rank_4_list() -> TensorRank4List<3, 1, 1, 1, 1, 2> {
    TensorRank4List::from(get_array())
}

#[test]
fn as_array() {
    get_tensor_rank_4_list()
        .as_array()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_4_entry, array_entry)| {
            tensor_rank_4_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_4_entry_i, array_entry_i)| {
                    tensor_rank_4_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_4_entry_ij, array_entry_ij)| {
                            tensor_rank_4_entry_ij
                                .iter()
                                .zip(array_entry_ij.iter())
                                .for_each(|(tensor_rank_4_entry_ijk, array_entry_ijk)| {
                                    tensor_rank_4_entry_ijk
                                        .iter()
                                        .zip(array_entry_ijk.iter())
                                        .for_each(|(tensor_rank_4_entry_ijkl, array_entry_ijkl)| {
                                            assert_eq!(tensor_rank_4_entry_ijkl, array_entry_ijkl)
                                        })
                                })
                        })
                },
            )
        });
}

#[test]
fn iter() {
    get_tensor_rank_4_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_4_entry, array_entry)| {
            tensor_rank_4_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_4_entry_i, array_entry_i)| {
                    tensor_rank_4_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_4_entry_ij, array_entry_ij)| {
                            tensor_rank_4_entry_ij
                                .iter()
                                .zip(array_entry_ij.iter())
                                .for_each(|(tensor_rank_4_entry_ijk, array_entry_ijk)| {
                                    tensor_rank_4_entry_ijk
                                        .iter()
                                        .zip(array_entry_ijk.iter())
                                        .for_each(|(tensor_rank_4_entry_ijkl, array_entry_ijkl)| {
                                            assert_eq!(tensor_rank_4_entry_ijkl, array_entry_ijkl)
                                        })
                                })
                        })
                },
            )
        });
}

#[test]
fn iter_mut() {
    get_tensor_rank_4_list()
        .iter_mut()
        .zip(get_array().iter_mut())
        .for_each(|(tensor_rank_4_entry, array_entry)| {
            tensor_rank_4_entry
                .iter_mut()
                .zip(array_entry.iter_mut())
                .for_each(|(tensor_rank_4_entry_i, array_entry_i)| {
                    tensor_rank_4_entry_i
                        .iter_mut()
                        .zip(array_entry_i.iter_mut())
                        .for_each(|(tensor_rank_4_entry_ij, array_entry_ij)| {
                            tensor_rank_4_entry_ij
                                .iter_mut()
                                .zip(array_entry_ij.iter_mut())
                                .for_each(|(tensor_rank_4_entry_ijk, array_entry_ijk)| {
                                    tensor_rank_4_entry_ijk
                                        .iter_mut()
                                        .zip(array_entry_ijk.iter_mut())
                                        .for_each(|(tensor_rank_4_entry_ijkl, array_entry_ijkl)| {
                                            assert_eq!(tensor_rank_4_entry_ijkl, array_entry_ijkl)
                                        })
                                })
                        })
                })
        });
}

#[test]
fn from() {
    get_tensor_rank_4_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_4_entry, array_entry)| {
            tensor_rank_4_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_4_entry_i, array_entry_i)| {
                    tensor_rank_4_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_4_entry_ij, array_entry_ij)| {
                            tensor_rank_4_entry_ij
                                .iter()
                                .zip(array_entry_ij.iter())
                                .for_each(|(tensor_rank_4_entry_ijk, array_entry_ijk)| {
                                    tensor_rank_4_entry_ijk
                                        .iter()
                                        .zip(array_entry_ijk.iter())
                                        .for_each(|(tensor_rank_4_entry_ijkl, array_entry_ijkl)| {
                                            assert_eq!(tensor_rank_4_entry_ijkl, array_entry_ijkl)
                                        })
                                })
                        })
                },
            )
        });
}

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

#[test]
fn zero() {
    TensorRank4List::<3, 1, 1, 1, 1, 8>::zero()
        .iter()
        .for_each(|tensor_rank_4_entry| {
            tensor_rank_4_entry
                .iter()
                .for_each(|tensor_rank_4_entry_i| {
                    tensor_rank_4_entry_i
                        .iter()
                        .for_each(|tensor_rank_4_entry_ij| {
                            tensor_rank_4_entry_ij
                                .iter()
                                .for_each(|tensor_rank_4_entry_ijk| {
                                    tensor_rank_4_entry_ijk.iter().for_each(
                                        |tensor_rank_4_entry_ijkl| {
                                            assert_eq!(tensor_rank_4_entry_ijkl, &0.0)
                                        },
                                    )
                                })
                        })
                })
        });
}