conspire 0.7.1

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
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

use crate::math::{
    Rank2, Tensor, TensorArray, TensorRank0, TensorRank2,
    test::{TestError, assert_eq, assert_eq_within_tols},
};
use std::cmp::Ordering;

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

fn get_array_dim_3() -> [[TensorRank0; 3]; 3] {
    [[1.0, 4.0, 6.0], [7.0, 2.0, 5.0], [9.0, 8.0, 3.0]]
}

fn get_array_dim_4() -> [[TensorRank0; 4]; 4] {
    [
        [1.0, 4.0, 6.0, 6.0],
        [1.0, 5.0, 1.0, 0.0],
        [1.0, 3.0, 5.0, 0.0],
        [1.0, 4.0, 6.0, 0.0],
    ]
}

fn get_array_dim_9() -> [[TensorRank0; 9]; 9] {
    [
        [2.0, 2.0, 4.0, 0.0, 0.0, 1.0, 1.0, 3.0, 3.0],
        [0.0, 0.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, 0.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_2_dim_2() -> TensorRank2<2, 1, 1> {
    TensorRank2::from(get_array_dim_2())
}

fn get_tensor_rank_2_dim_3() -> TensorRank2<3, 1, 1> {
    TensorRank2::from(get_array_dim_3())
}

fn get_tensor_rank_2_dim_4() -> TensorRank2<4, 1, 1> {
    TensorRank2::from(get_array_dim_4())
}

fn get_tensor_rank_2_dim_9() -> TensorRank2<9, 1, 1> {
    TensorRank2::from(get_array_dim_9())
}

#[test]
fn determinant_dim_2() -> Result<(), TestError> {
    assert_eq(&get_tensor_rank_2_dim_2().determinant(), &-2.0)
}

#[test]
fn determinant_dim_3() -> Result<(), TestError> {
    assert_eq(&get_tensor_rank_2_dim_3().determinant(), &290.0)
}

#[test]
fn determinant_dim_4() -> Result<(), TestError> {
    assert_eq_within_tols(&get_tensor_rank_2_dim_4().determinant(), &36.0)
}

#[test]
fn determinant_dim_9() -> Result<(), TestError> {
    assert_eq_within_tols(&get_tensor_rank_2_dim_9().determinant(), &5297.0)
}

#[test]
fn inverse_dim_2() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_2() * get_tensor_rank_2_dim_2().inverse()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_dim_3() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_3() * get_tensor_rank_2_dim_3().inverse()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_dim_4() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_4() * get_tensor_rank_2_dim_4().inverse()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_dim_9() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_9() * get_tensor_rank_2_dim_9().inverse()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_and_determinant_dim_2() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_2();
    let (inverse, determinant) = tensor_rank_2.inverse_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse, &tensor_rank_2.inverse())
}

#[test]
fn inverse_and_determinant_dim_3() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_3();
    let (inverse, determinant) = tensor_rank_2.inverse_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse, &tensor_rank_2.inverse())
}

#[test]
fn inverse_and_determinant_dim_4() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_4();
    let (inverse, determinant) = tensor_rank_2.inverse_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse, &tensor_rank_2.inverse())
}

#[test]
fn inverse_and_determinant_dim_9() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_9();
    let (inverse, determinant) = tensor_rank_2.inverse_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse, &tensor_rank_2.inverse())
}

#[test]
fn inverse_transpose_dim_2() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_2().transpose() * get_tensor_rank_2_dim_2().inverse_transpose()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_transpose_dim_3() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_3().transpose() * get_tensor_rank_2_dim_3().inverse_transpose()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_transpose_dim_4() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_4().transpose() * get_tensor_rank_2_dim_4().inverse_transpose()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_transpose_9() -> Result<(), TestError> {
    assert_eq_within_tols(
        &(get_tensor_rank_2_dim_9().transpose() * get_tensor_rank_2_dim_9().inverse_transpose()),
        &TensorRank2::identity(),
    )
}

#[test]
fn inverse_transpose_and_determinant_dim_2() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_2();
    let (inverse_transpose, determinant) = tensor_rank_2.inverse_transpose_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse_transpose, &tensor_rank_2.inverse_transpose())
}

#[test]
fn inverse_transpose_and_determinant_dim_3() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_3();
    let (inverse_transpose, determinant) = tensor_rank_2.inverse_transpose_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse_transpose, &tensor_rank_2.inverse_transpose())
}

#[test]
fn inverse_transpose_and_determinant_dim_4() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_4();
    let (inverse_transpose, determinant) = tensor_rank_2.inverse_transpose_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse_transpose, &tensor_rank_2.inverse_transpose())
}

#[test]
fn inverse_transpose_and_determinant_dim_9() -> Result<(), TestError> {
    let tensor_rank_2 = get_tensor_rank_2_dim_9();
    let (inverse_transpose, determinant) = tensor_rank_2.inverse_transpose_and_determinant();
    assert_eq(&determinant, &tensor_rank_2.determinant())?;
    assert_eq(&inverse_transpose, &tensor_rank_2.inverse_transpose())
}

#[test]
fn lu_decomposition() -> Result<(), TestError> {
    let (l, u, p) = get_tensor_rank_2_dim_9().lu_decomposition();
    l.iter()
        .enumerate()
        .zip(u.iter())
        .for_each(|((i, l_i), u_i)| {
            l_i.iter()
                .enumerate()
                .zip(u_i.iter())
                .for_each(|((j, l_ij), u_ij)| match i.cmp(&j) {
                    Ordering::Equal => assert_eq!(l_ij, &1.0),
                    Ordering::Greater => assert_eq!(u_ij, &0.0),
                    Ordering::Less => assert_eq!(l_ij, &0.0),
                })
        });
    assert_eq_within_tols(
        &(l * u),
        &p.iter()
            .map(|&p_i| get_tensor_rank_2_dim_9()[p_i].clone())
            .collect(),
    )
}