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

use crate::math::{Tensor, TensorArray, TensorRank0, TensorRank0List};

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

fn get_tensor_rank_0_list() -> TensorRank0List<4> {
    TensorRank0List::from(get_array())
}

fn get_other_tensor_rank_0_list() -> TensorRank0List<4> {
    TensorRank0List::from([5.0, 6.0, 7.0, 8.0])
}

#[test]
fn full_contraction() {
    assert_eq!(
        get_tensor_rank_0_list().full_contraction(&get_other_tensor_rank_0_list()),
        70.0
    )
}

#[test]
fn from_iter() {
    let into_iterator = (0..8).map(|x| x as TensorRank0);
    let tensor_rank_0_list = TensorRank0List::<8>::from_iter(into_iterator.clone());
    tensor_rank_0_list
        .iter()
        .zip(into_iterator)
        .for_each(|(tensor_rank_0_list_i, value_i)| assert_eq!(tensor_rank_0_list_i, &value_i));
}

#[test]
fn identity() {
    TensorRank0List::<8>::identity()
        .iter()
        .for_each(|tensor_rank_0_list_i| assert_eq!(tensor_rank_0_list_i, &1.0));
}

#[test]
fn iter() {
    get_tensor_rank_0_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_0_list_i, array_i)| assert_eq!(tensor_rank_0_list_i, array_i));
}

#[test]
fn iter_mut() {
    get_tensor_rank_0_list()
        .iter_mut()
        .zip(get_array().iter_mut())
        .for_each(|(tensor_rank_0_list_i, array_i)| assert_eq!(tensor_rank_0_list_i, array_i));
}

#[test]
fn mul_tensor_rank_1_list_to_self() {
    assert_eq!(
        get_tensor_rank_0_list() * get_other_tensor_rank_0_list(),
        70.0
    )
}

#[test]
fn mul_tensor_rank_1_list_ref_to_self() {
    assert_eq!(
        get_tensor_rank_0_list() * &get_other_tensor_rank_0_list(),
        70.0
    )
}

#[test]
fn mul_tensor_rank_1_list_to_self_ref() {
    assert_eq!(
        &get_tensor_rank_0_list() * get_other_tensor_rank_0_list(),
        70.0
    )
}

#[test]
fn mul_tensor_rank_1_list_ref_to_self_ref() {
    assert_eq!(
        &get_tensor_rank_0_list() * &get_other_tensor_rank_0_list(),
        70.0
    )
}

#[test]
fn from() {
    get_tensor_rank_0_list()
        .iter()
        .zip(get_array().iter())
        .for_each(|(tensor_rank_0_list_i, array_i)| assert_eq!(tensor_rank_0_list_i, array_i));
}

#[test]
fn zero() {
    TensorRank0List::<8>::zero()
        .iter()
        .for_each(|tensor_rank_0_list_i| assert_eq!(tensor_rank_0_list_i, &0.0));
}