conspire 0.7.7

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

use crate::math::{Tensor, TensorRank0, assert::FiniteDifference};
use crate::math::{TensorArray, TensorRank2, tensor::vec::TensorVector};
use crate::units::Dimensionless;

/// A vector of rank-2 tensors.
pub type TensorRank2Vec<const D: usize, I, J, U = Dimensionless> =
    TensorVector<TensorRank2<D, I, J, U>>;

impl<const D: usize, I, J, U> TensorRank2Vec<D, I, J, U> {
    pub fn zero(len: usize) -> Self {
        (0..len).map(|_| TensorRank2::zero()).collect()
    }
}

impl<const D: usize, I, J, U> FiniteDifference for TensorRank2Vec<D, I, J, U> {
    fn error_fd(&self, comparator: &Self, epsilon: TensorRank0) -> Option<(bool, usize)> {
        let error_count = self
            .iter()
            .zip(comparator.iter())
            .map(|(self_a, comparator_a)| {
                self_a
                    .iter()
                    .zip(comparator_a.iter())
                    .map(|(self_a_i, comparator_a_i)| {
                        self_a_i
                            .iter()
                            .zip(comparator_a_i.iter())
                            .filter(|&(&self_a_ij, &comparator_a_ij)| {
                                self_a_ij.differs(comparator_a_ij, epsilon)
                            })
                            .count()
                    })
                    .sum::<usize>()
            })
            .sum();
        if error_count > 0 {
            Some((true, error_count))
        } else {
            None
        }
    }
}