conspire/math/tensor/rank_1/vec/
mod.rs

1#[cfg(test)]
2mod test;
3
4use crate::math::{
5    Jacobian, Solution, Tensor, TensorRank0, TensorRank1, TensorRank2Vec2D, Vector,
6    tensor::vec::TensorVector,
7};
8use std::{
9    mem::{forget, transmute},
10    ops::{Div, Sub},
11};
12
13#[cfg(test)]
14use crate::math::tensor::test::ErrorTensor;
15
16pub type TensorRank1Vec<const D: usize, const I: usize> = TensorVector<TensorRank1<D, I>>;
17
18impl<const D: usize, const I: usize> TensorRank1Vec<D, I> {
19    pub fn zero(len: usize) -> Self {
20        (0..len).map(|_| super::zero()).collect()
21    }
22}
23
24impl<const D: usize, const I: usize, const N: usize> From<[[TensorRank0; D]; N]>
25    for TensorRank1Vec<D, I>
26{
27    fn from(array: [[TensorRank0; D]; N]) -> Self {
28        array.into_iter().map(TensorRank1::from).collect()
29    }
30}
31
32impl<const D: usize, const I: usize> From<Vec<[TensorRank0; D]>> for TensorRank1Vec<D, I> {
33    fn from(vec: Vec<[TensorRank0; D]>) -> Self {
34        unsafe { transmute(vec) }
35    }
36}
37
38impl<const D: usize, const I: usize> From<TensorRank1Vec<D, I>> for Vec<[TensorRank0; D]> {
39    fn from(tensor_rank_1_vec: TensorRank1Vec<D, I>) -> Self {
40        unsafe { transmute(tensor_rank_1_vec) }
41    }
42}
43
44impl<const D: usize, const I: usize> From<Vec<Vec<TensorRank0>>> for TensorRank1Vec<D, I> {
45    fn from(vec: Vec<Vec<TensorRank0>>) -> Self {
46        vec.into_iter()
47            .map(|tensor_rank_1| tensor_rank_1.into())
48            .collect()
49    }
50}
51
52impl<const D: usize, const I: usize> From<TensorRank1Vec<D, I>> for Vec<Vec<TensorRank0>> {
53    fn from(tensor_rank_1_vec: TensorRank1Vec<D, I>) -> Self {
54        tensor_rank_1_vec
55            .into_iter()
56            .map(|tensor_rank_1| tensor_rank_1.into())
57            .collect()
58    }
59}
60
61impl From<TensorRank1Vec<3, 0>> for TensorRank1Vec<3, 1> {
62    fn from(tensor_rank_1_vec: TensorRank1Vec<3, 0>) -> Self {
63        unsafe { transmute(tensor_rank_1_vec) }
64    }
65}
66
67impl From<TensorRank1Vec<3, 1>> for TensorRank1Vec<3, 0> {
68    fn from(tensor_rank_1_vec: TensorRank1Vec<3, 1>) -> Self {
69        unsafe { transmute(tensor_rank_1_vec) }
70    }
71}
72
73impl<const D: usize, const I: usize> From<Vector> for TensorRank1Vec<D, I> {
74    fn from(vector: Vector) -> Self {
75        let n = vector.len();
76        if n.is_multiple_of(D) {
77            let length = n / D;
78            let pointer = vector.as_ptr() as *mut TensorRank1<D, I>;
79            forget(vector);
80            unsafe { Self::from(Vec::from_raw_parts(pointer, length, length)) }
81        } else {
82            panic!("Vector length mismatch.")
83        }
84    }
85}
86
87impl<const D: usize, const I: usize> Jacobian for TensorRank1Vec<D, I> {
88    fn fill_into(self, vector: &mut Vector) {
89        self.into_iter()
90            .flatten()
91            .zip(vector.iter_mut())
92            .for_each(|(self_i, vector_i)| *vector_i = self_i)
93    }
94    fn fill_into_chained(self, other: Vector, vector: &mut Vector) {
95        self.into_iter()
96            .flatten()
97            .chain(other)
98            .zip(vector.iter_mut())
99            .for_each(|(self_i, vector_i)| *vector_i = self_i)
100    }
101    fn retain_from(self, retained: &[bool]) -> Vector {
102        self.into_iter()
103            .flatten()
104            .zip(retained.iter())
105            .filter(|(_, retained)| **retained)
106            .map(|(entry, _)| entry)
107            .collect()
108    }
109    fn zero_out(&mut self, indices: &[usize]) {
110        indices
111            .iter()
112            .for_each(|index| self[index / D][index % D] = 0.0)
113    }
114}
115
116impl<const D: usize, const I: usize> Solution for TensorRank1Vec<D, I> {
117    fn decrement_from(&mut self, other: &Vector) {
118        self.iter_mut()
119            .flat_map(|x| x.iter_mut())
120            .zip(other.iter())
121            .for_each(|(self_i, vector_i)| *self_i -= vector_i)
122    }
123    fn decrement_from_chained(&mut self, other: &mut Vector, vector: Vector) {
124        self.iter_mut()
125            .flat_map(|x| x.iter_mut())
126            .chain(other.iter_mut())
127            .zip(vector)
128            .for_each(|(entry_i, vector_i)| *entry_i -= vector_i)
129    }
130    fn decrement_from_retained(&mut self, retained: &[bool], other: &Vector) {
131        self.iter_mut()
132            .flat_map(|x| x.iter_mut())
133            .zip(retained.iter())
134            .filter(|(_, retained_i)| **retained_i)
135            .zip(other.iter())
136            .for_each(|((self_i, _), vector_i)| *self_i -= vector_i)
137    }
138}
139
140impl<const D: usize, const I: usize> Sub<Vector> for TensorRank1Vec<D, I> {
141    type Output = Self;
142    fn sub(mut self, vector: Vector) -> Self::Output {
143        self.iter_mut().enumerate().for_each(|(a, self_a)| {
144            self_a
145                .iter_mut()
146                .enumerate()
147                .for_each(|(i, self_a_i)| *self_a_i -= vector[D * a + i])
148        });
149        self
150    }
151}
152
153impl<const D: usize, const I: usize> Sub<&Vector> for TensorRank1Vec<D, I> {
154    type Output = Self;
155    fn sub(mut self, vector: &Vector) -> Self::Output {
156        self.iter_mut().enumerate().for_each(|(a, self_a)| {
157            self_a
158                .iter_mut()
159                .enumerate()
160                .for_each(|(i, self_a_i)| *self_a_i -= vector[D * a + i])
161        });
162        self
163    }
164}
165
166impl<const D: usize, const I: usize, const J: usize> Div<TensorRank2Vec2D<D, I, J>>
167    for &TensorRank1Vec<D, I>
168{
169    type Output = TensorRank1Vec<D, J>;
170    fn div(self, _tensor_rank_2_vec_2d: TensorRank2Vec2D<D, I, J>) -> Self::Output {
171        todo!()
172    }
173}
174
175#[cfg(test)]
176impl<const D: usize, const I: usize> ErrorTensor for TensorRank1Vec<D, I> {
177    fn error_fd(&self, comparator: &Self, epsilon: &TensorRank0) -> Option<(bool, usize)> {
178        let error_count = self
179            .iter()
180            .zip(comparator.iter())
181            .map(|(entry, comparator_entry)| {
182                entry
183                    .iter()
184                    .zip(comparator_entry.iter())
185                    .filter(|&(&entry_i, &comparator_entry_i)| {
186                        &(entry_i / comparator_entry_i - 1.0).abs() >= epsilon
187                            && (&entry_i.abs() >= epsilon || &comparator_entry_i.abs() >= epsilon)
188                    })
189                    .count()
190            })
191            .sum();
192        if error_count > 0 {
193            let auxiliary = self
194                .iter()
195                .zip(comparator.iter())
196                .map(|(entry, comparator_entry)| {
197                    entry
198                        .iter()
199                        .zip(comparator_entry.iter())
200                        .filter(|&(&entry_i, &comparator_entry_i)| {
201                            &(entry_i / comparator_entry_i - 1.0).abs() >= epsilon
202                                && &(entry_i - comparator_entry_i).abs() >= epsilon
203                                && (&entry_i.abs() >= epsilon
204                                    || &comparator_entry_i.abs() >= epsilon)
205                        })
206                        .count()
207                })
208                .sum::<usize>()
209                > 0;
210            Some((auxiliary, error_count))
211        } else {
212            None
213        }
214    }
215}
conspire/math/tensor/rank_1/vec/mod.rs

conspire/math/tensor/rank_1/vec/
mod.rs
