flavio 0.5.0

flavio welcomes you
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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

use super::{
    super::super::{Tensor, TensorArray},
    TensorRank0, TensorRank3, TensorRank3List,
};

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

fn get_tensor_rank_3_list() -> TensorRank3List<3, 1, 1, 1, 2> {
    TensorRank3List::new(get_array())
}

fn get_other_tensor_rank_3_list() -> TensorRank3List<3, 1, 1, 1, 2> {
    TensorRank3List::new([
        [
            [[5.0, 0.0, 2.0], [3.0, 0.0, 6.0], [5.0, 1.0, 4.0]],
            [[0.0, 2.0, 0.0], [0.0, 3.0, 0.0], [1.0, 3.0, 3.0]],
            [[4.0, 6.0, 6.0], [4.0, 3.0, 4.0], [2.0, 4.0, 0.0]],
        ],
        [
            [[2.0, 4.0, 0.0], [5.0, 1.0, 3.0], [4.0, 2.0, 6.0]],
            [[4.0, 5.0, 2.0], [4.0, 4.0, 0.0], [2.0, 6.0, 0.0]],
            [[6.0, 6.0, 6.0], [5.0, 4.0, 1.0], [4.0, 3.0, 0.0]],
        ],
    ])
}

fn get_other_tensor_rank_3_list_add_tensor_rank_3_list() -> TensorRank3List<3, 1, 1, 1, 2> {
    TensorRank3List::new([
        [
            [[6.0, 2.0, 3.0], [3.0, 3.0, 7.0], [8.0, 2.0, 6.0]],
            [[2.0, 2.0, 3.0], [0.0, 5.0, 3.0], [4.0, 6.0, 5.0]],
            [[6.0, 8.0, 6.0], [5.0, 3.0, 4.0], [2.0, 6.0, 1.0]],
        ],
        [
            [[4.0, 6.0, 0.0], [6.0, 1.0, 3.0], [4.0, 4.0, 7.0]],
            [[6.0, 5.0, 5.0], [4.0, 6.0, 3.0], [5.0, 9.0, 2.0]],
            [[7.0, 8.0, 7.0], [5.0, 7.0, 2.0], [7.0, 4.0, 2.0]],
        ],
    ])
}

#[test]
fn add_assign_tensor_rank_3_list() {
    let mut tensor_rank_3_list = get_tensor_rank_3_list();
    tensor_rank_3_list += get_other_tensor_rank_3_list();
    tensor_rank_3_list
        .iter()
        .zip(get_other_tensor_rank_3_list_add_tensor_rank_3_list().iter())
        .for_each(|(tensor_rank_3, res_tensor_rank_3)| {
            tensor_rank_3.iter().zip(res_tensor_rank_3.iter()).for_each(
                |(tensor_rank_3_i, res_tensor_rank_3_i)| {
                    tensor_rank_3_i
                        .iter()
                        .zip(res_tensor_rank_3_i.iter())
                        .for_each(|(tensor_rank_3_ij, res_tensor_rank_3_ij)| {
                            tensor_rank_3_ij
                                .iter()
                                .zip(res_tensor_rank_3_ij.iter())
                                .for_each(|(tensor_rank_3_ijk, res_tensor_rank_3_ijk)| {
                                    assert_eq!(tensor_rank_3_ijk, res_tensor_rank_3_ijk)
                                })
                        })
                },
            )
        })
}

#[test]
fn add_assign_tensor_rank_3_list_ref() {
    let mut tensor_rank_3_list = get_tensor_rank_3_list();
    tensor_rank_3_list += &get_other_tensor_rank_3_list();
    tensor_rank_3_list
        .iter()
        .zip(get_other_tensor_rank_3_list_add_tensor_rank_3_list().iter())
        .for_each(|(tensor_rank_3, res_tensor_rank_3)| {
            tensor_rank_3.iter().zip(res_tensor_rank_3.iter()).for_each(
                |(tensor_rank_3_i, res_tensor_rank_3_i)| {
                    tensor_rank_3_i
                        .iter()
                        .zip(res_tensor_rank_3_i.iter())
                        .for_each(|(tensor_rank_3_ij, res_tensor_rank_3_ij)| {
                            tensor_rank_3_ij
                                .iter()
                                .zip(res_tensor_rank_3_ij.iter())
                                .for_each(|(tensor_rank_3_ijk, res_tensor_rank_3_ijk)| {
                                    assert_eq!(tensor_rank_3_ijk, res_tensor_rank_3_ijk)
                                })
                        })
                },
            )
        })
}

#[test]
fn from_iter() {
    let into_iterator = get_tensor_rank_3_list().0.into_iter();
    let tensor_rank_3_list =
        TensorRank3List::<3, 1, 1, 1, 2>::from_iter(get_tensor_rank_3_list().0);
    tensor_rank_3_list
        .iter()
        .zip(into_iterator)
        .for_each(|(tensor_rank_3_entry, array_entry)| {
            tensor_rank_3_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_3_entry_i, array_entry_i)| {
                    tensor_rank_3_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_3_entry_ij, array_entry_ij)| {
                            tensor_rank_3_entry_ij
                                .iter()
                                .zip(array_entry_ij.iter())
                                .for_each(|(tensor_rank_3_entry_ijk, array_entry_ijk)| {
                                    assert_eq!(tensor_rank_3_entry_ijk, array_entry_ijk)
                                })
                        })
                },
            )
        })
}

#[test]
fn iter() {
    get_tensor_rank_3_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_3_entry, array_entry)| {
            tensor_rank_3_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_3_entry_i, array_entry_i)| {
                    tensor_rank_3_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_3_entry_ij, array_entry_ij)| {
                            tensor_rank_3_entry_ij
                                .iter()
                                .zip(array_entry_ij.iter())
                                .for_each(|(tensor_rank_3_entry_ijk, array_entry_ijk)| {
                                    assert_eq!(tensor_rank_3_entry_ijk, array_entry_ijk)
                                })
                        })
                },
            )
        })
}

#[test]
fn iter_mut() {
    get_tensor_rank_3_list()
        .iter_mut()
        .zip(get_array().iter_mut())
        .for_each(|(tensor_rank_3_entry, array_entry)| {
            tensor_rank_3_entry
                .iter_mut()
                .zip(array_entry.iter_mut())
                .for_each(|(tensor_rank_3_entry_i, array_entry_i)| {
                    tensor_rank_3_entry_i
                        .iter_mut()
                        .zip(array_entry_i.iter_mut())
                        .for_each(|(tensor_rank_3_entry_ij, array_entry_ij)| {
                            tensor_rank_3_entry_ij
                                .iter_mut()
                                .zip(array_entry_ij.iter_mut())
                                .for_each(|(tensor_rank_3_entry_ijk, array_entry_ijk)| {
                                    assert_eq!(tensor_rank_3_entry_ijk, array_entry_ijk)
                                })
                        })
                })
        })
}

#[test]
fn new() {
    get_tensor_rank_3_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_3_entry, array_entry)| {
            tensor_rank_3_entry.iter().zip(array_entry.iter()).for_each(
                |(tensor_rank_3_entry_i, array_entry_i)| {
                    tensor_rank_3_entry_i
                        .iter()
                        .zip(array_entry_i.iter())
                        .for_each(|(tensor_rank_3_entry_ij, array_entry_ij)| {
                            tensor_rank_3_entry_ij
                                .iter()
                                .zip(array_entry_ij.iter())
                                .for_each(|(tensor_rank_3_entry_ijk, array_entry_ijk)| {
                                    assert_eq!(tensor_rank_3_entry_ijk, array_entry_ijk)
                                })
                        })
                },
            )
        })
}

#[test]
fn size() {
    assert_eq!(
        std::mem::size_of::<TensorRank3List::<3, 1, 1, 1, 2>>(),
        std::mem::size_of::<[TensorRank3::<3, 1, 1, 1>; 2]>()
    )
}

#[test]
fn zero() {
    TensorRank3List::<3, 1, 1, 1, 2>::zero()
        .iter()
        .for_each(|tensor_rank_3_entry| {
            tensor_rank_3_entry
                .iter()
                .for_each(|tensor_rank_3_entry_i| {
                    tensor_rank_3_entry_i
                        .iter()
                        .for_each(|tensor_rank_3_entry_ij| {
                            tensor_rank_3_entry_ij
                                .iter()
                                .for_each(|tensor_rank_3_entry_ijk| {
                                    assert_eq!(tensor_rank_3_entry_ijk, &0.0)
                                })
                        })
                })
        })
}