conspire/math/matrix/vector/
mod.rs

1#[cfg(test)]
2use crate::math::test::ErrorTensor;
3
4use crate::math::{
5    Jacobian, Matrix, Scalar, Solution, Tensor, TensorRank1Vec, TensorRank2, TensorVec,
6    write_tensor_rank_0,
7};
8use std::{
9    fmt::{Display, Formatter, Result},
10    ops::{
11        Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, RangeFrom, RangeTo, Sub,
12        SubAssign,
13    },
14    vec::IntoIter,
15};
16
17/// A vector.
18#[derive(Clone, Debug, PartialEq)]
19pub struct Vector(Vec<Scalar>);
20
21impl Vector {
22    pub fn as_slice(&self) -> &[Scalar] {
23        self.0.as_slice()
24    }
25    pub fn ones(len: usize) -> Self {
26        Self(vec![1.0; len])
27    }
28}
29
30#[cfg(test)]
31impl ErrorTensor for Vector {
32    fn error_fd(&self, comparator: &Self, epsilon: &Scalar) -> Option<(bool, usize)> {
33        let error_count = self
34            .iter()
35            .zip(comparator.iter())
36            .map(|(entry, comparator_entry)| {
37                entry
38                    .iter()
39                    .zip(comparator_entry.iter())
40                    .filter(|&(&entry_i, &comparator_entry_i)| {
41                        &(entry_i / comparator_entry_i - 1.0).abs() >= epsilon
42                            && (&entry_i.abs() >= epsilon || &comparator_entry_i.abs() >= epsilon)
43                    })
44                    .count()
45            })
46            .sum();
47        if error_count > 0 {
48            let auxiliary = self
49                .iter()
50                .zip(comparator.iter())
51                .map(|(entry, comparator_entry)| {
52                    entry
53                        .iter()
54                        .zip(comparator_entry.iter())
55                        .filter(|&(&entry_i, &comparator_entry_i)| {
56                            &(entry_i / comparator_entry_i - 1.0).abs() >= epsilon
57                                && &(entry_i - comparator_entry_i).abs() >= epsilon
58                                && (&entry_i.abs() >= epsilon
59                                    || &comparator_entry_i.abs() >= epsilon)
60                        })
61                        .count()
62                })
63                .sum::<usize>()
64                > 0;
65            Some((auxiliary, error_count))
66        } else {
67            None
68        }
69    }
70}
71
72impl Display for Vector {
73    fn fmt(&self, f: &mut Formatter) -> Result {
74        write!(f, "\x1B[s")?;
75        write!(f, "[")?;
76        self.0.chunks(5).enumerate().try_for_each(|(i, chunk)| {
77            chunk
78                .iter()
79                .try_for_each(|entry| write_tensor_rank_0(f, entry))?;
80            if (i + 1) * 5 < self.len() {
81                writeln!(f, "\x1B[2D,")?;
82                write!(f, "\x1B[u")?;
83                write!(f, "\x1B[{}B ", i + 1)?;
84            }
85            Ok(())
86        })?;
87        write!(f, "\x1B[2D]")?;
88        Ok(())
89    }
90}
91
92impl<const D: usize, const I: usize> From<TensorRank1Vec<D, I>> for Vector {
93    fn from(tensor_rank_1_vec: TensorRank1Vec<D, I>) -> Self {
94        tensor_rank_1_vec.into_iter().flatten().collect()
95    }
96}
97
98impl<const D: usize, const I: usize, const J: usize> From<TensorRank2<D, I, J>> for Vector {
99    fn from(tensor_rank_2: TensorRank2<D, I, J>) -> Self {
100        tensor_rank_2.into_iter().flatten().collect()
101    }
102}
103
104impl FromIterator<Scalar> for Vector {
105    fn from_iter<Ii: IntoIterator<Item = Scalar>>(into_iterator: Ii) -> Self {
106        Self(Vec::from_iter(into_iterator))
107    }
108}
109
110impl Index<usize> for Vector {
111    type Output = Scalar;
112    fn index(&self, index: usize) -> &Self::Output {
113        &self.0[index]
114    }
115}
116
117impl Index<RangeTo<usize>> for Vector {
118    type Output = [Scalar];
119    fn index(&self, indices: RangeTo<usize>) -> &Self::Output {
120        &self.0[indices]
121    }
122}
123
124impl Index<RangeFrom<usize>> for Vector {
125    type Output = [Scalar];
126    fn index(&self, indices: RangeFrom<usize>) -> &Self::Output {
127        &self.0[indices]
128    }
129}
130
131impl IndexMut<usize> for Vector {
132    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
133        &mut self.0[index]
134    }
135}
136
137impl Tensor for Vector {
138    type Item = Scalar;
139    fn iter(&self) -> impl Iterator<Item = &Self::Item> {
140        self.0.iter()
141    }
142    fn iter_mut(&mut self) -> impl Iterator<Item = &mut Self::Item> {
143        self.0.iter_mut()
144    }
145    fn norm_inf(&self) -> Scalar {
146        self.iter().fold(0.0, |acc, entry| entry.abs().max(acc))
147    }
148}
149
150impl Solution for Vector {
151    fn decrement_from_chained(&mut self, other: &mut Self, vector: Vector) {
152        self.iter_mut()
153            .chain(other.iter_mut())
154            .zip(vector)
155            .for_each(|(entry_i, vector_i)| *entry_i -= vector_i)
156    }
157}
158
159impl Jacobian for Vector {
160    fn fill_into(self, vector: &mut Vector) {
161        self.into_iter()
162            .zip(vector.iter_mut())
163            .for_each(|(self_i, vector_i)| *vector_i = self_i)
164    }
165    fn fill_into_chained(self, other: Self, vector: &mut Self) {
166        self.into_iter()
167            .chain(other)
168            .zip(vector.iter_mut())
169            .for_each(|(entry_i, vector_i)| *vector_i = entry_i)
170    }
171}
172
173impl IntoIterator for Vector {
174    type Item = Scalar;
175    type IntoIter = IntoIter<Self::Item>;
176    fn into_iter(self) -> Self::IntoIter {
177        self.0.into_iter()
178    }
179}
180
181impl TensorVec for Vector {
182    type Item = Scalar;
183    type Slice<'a> = &'a [Scalar];
184    fn append(&mut self, other: &mut Self) {
185        self.0.append(&mut other.0)
186    }
187    fn is_empty(&self) -> bool {
188        self.0.is_empty()
189    }
190    fn len(&self) -> usize {
191        self.0.len()
192    }
193    fn new(slice: Self::Slice<'_>) -> Self {
194        slice.iter().copied().collect()
195    }
196    fn push(&mut self, item: Self::Item) {
197        self.0.push(item)
198    }
199    fn remove(&mut self, index: usize) -> Self::Item {
200        self.0.remove(index)
201    }
202    fn retain<F>(&mut self, f: F)
203    where
204        F: FnMut(&Self::Item) -> bool,
205    {
206        self.0.retain(f)
207    }
208    fn swap_remove(&mut self, index: usize) -> Self::Item {
209        self.0.swap_remove(index)
210    }
211    fn zero(len: usize) -> Self {
212        Self(vec![0.0; len])
213    }
214}
215
216impl Div<Scalar> for Vector {
217    type Output = Self;
218    fn div(mut self, scalar: Scalar) -> Self::Output {
219        self /= &scalar;
220        self
221    }
222}
223
224impl Div<&Scalar> for Vector {
225    type Output = Self;
226    fn div(mut self, scalar: &Scalar) -> Self::Output {
227        self /= scalar;
228        self
229    }
230}
231
232impl DivAssign<Scalar> for Vector {
233    fn div_assign(&mut self, scalar: Scalar) {
234        self.iter_mut().for_each(|entry| *entry /= &scalar);
235    }
236}
237
238impl DivAssign<&Scalar> for Vector {
239    fn div_assign(&mut self, scalar: &Scalar) {
240        self.iter_mut().for_each(|entry| *entry /= scalar);
241    }
242}
243
244impl Mul<Scalar> for Vector {
245    type Output = Self;
246    fn mul(mut self, scalar: Scalar) -> Self::Output {
247        self *= &scalar;
248        self
249    }
250}
251
252impl Mul<&Scalar> for Vector {
253    type Output = Self;
254    fn mul(mut self, scalar: &Scalar) -> Self::Output {
255        self *= scalar;
256        self
257    }
258}
259
260impl Mul<Scalar> for &Vector {
261    type Output = Vector;
262    fn mul(self, scalar: Scalar) -> Self::Output {
263        self.iter().map(|self_i| self_i * scalar).collect()
264    }
265}
266
267impl Mul<&Scalar> for &Vector {
268    type Output = Vector;
269    fn mul(self, scalar: &Scalar) -> Self::Output {
270        self.iter().map(|self_i| self_i * scalar).collect()
271    }
272}
273
274impl MulAssign<Scalar> for Vector {
275    fn mul_assign(&mut self, scalar: Scalar) {
276        self.iter_mut().for_each(|entry| *entry *= &scalar);
277    }
278}
279
280impl MulAssign<&Scalar> for Vector {
281    fn mul_assign(&mut self, scalar: &Scalar) {
282        self.iter_mut().for_each(|entry| *entry *= scalar);
283    }
284}
285
286impl Add for Vector {
287    type Output = Self;
288    fn add(mut self, vector: Self) -> Self::Output {
289        self += vector;
290        self
291    }
292}
293
294impl Add<&Self> for Vector {
295    type Output = Self;
296    fn add(mut self, vector: &Self) -> Self::Output {
297        self += vector;
298        self
299    }
300}
301
302impl AddAssign for Vector {
303    fn add_assign(&mut self, vector: Self) {
304        self.iter_mut()
305            .zip(vector.iter())
306            .for_each(|(self_entry, scalar)| *self_entry += scalar);
307    }
308}
309
310impl AddAssign<&Self> for Vector {
311    fn add_assign(&mut self, vector: &Self) {
312        self.iter_mut()
313            .zip(vector.iter())
314            .for_each(|(self_entry, scalar)| *self_entry += scalar);
315    }
316}
317
318impl Mul for Vector {
319    type Output = Scalar;
320    fn mul(self, vector: Self) -> Self::Output {
321        self.iter()
322            .zip(vector.iter())
323            .map(|(self_i, vector_i)| self_i * vector_i)
324            .sum()
325    }
326}
327
328impl Mul<&Self> for Vector {
329    type Output = Scalar;
330    fn mul(self, vector: &Self) -> Self::Output {
331        self.iter()
332            .zip(vector.iter())
333            .map(|(self_i, vector_i)| self_i * vector_i)
334            .sum()
335    }
336}
337
338impl Mul<Vector> for &Vector {
339    type Output = Scalar;
340    fn mul(self, vector: Vector) -> Self::Output {
341        self.iter()
342            .zip(vector.iter())
343            .map(|(self_i, vector_i)| self_i * vector_i)
344            .sum()
345    }
346}
347
348impl Mul for &Vector {
349    type Output = Scalar;
350    fn mul(self, vector: Self) -> Self::Output {
351        self.iter()
352            .zip(vector.iter())
353            .map(|(self_i, vector_i)| self_i * vector_i)
354            .sum()
355    }
356}
357
358impl Sub for Vector {
359    type Output = Self;
360    fn sub(mut self, vector: Self) -> Self::Output {
361        self -= vector;
362        self
363    }
364}
365
366impl Sub<&Self> for Vector {
367    type Output = Self;
368    fn sub(mut self, vector: &Self) -> Self::Output {
369        self -= vector;
370        self
371    }
372}
373
374impl Sub<Vector> for &Vector {
375    type Output = Vector;
376    fn sub(self, mut vector: Vector) -> Self::Output {
377        vector
378            .iter_mut()
379            .zip(self.iter())
380            .for_each(|(vector_i, self_i)| *vector_i = self_i - *vector_i);
381        vector
382    }
383}
384
385impl Sub for &Vector {
386    type Output = Vector;
387    fn sub(self, vector: Self) -> Self::Output {
388        vector
389            .iter()
390            .zip(self.iter())
391            .map(|(vector_i, self_i)| self_i - vector_i)
392            .collect()
393    }
394}
395
396impl SubAssign for Vector {
397    fn sub_assign(&mut self, vector: Self) {
398        self.iter_mut()
399            .zip(vector.iter())
400            .for_each(|(self_entry, tensor_rank_1)| *self_entry -= tensor_rank_1);
401    }
402}
403
404impl SubAssign<&Self> for Vector {
405    fn sub_assign(&mut self, vector: &Self) {
406        self.iter_mut()
407            .zip(vector.iter())
408            .for_each(|(self_entry, tensor_rank_1)| *self_entry -= tensor_rank_1);
409    }
410}
411
412impl SubAssign<&[Scalar]> for Vector {
413    fn sub_assign(&mut self, slice: &[Scalar]) {
414        self.iter_mut()
415            .zip(slice.iter())
416            .for_each(|(self_entry, tensor_rank_1)| *self_entry -= tensor_rank_1);
417    }
418}
419
420impl Mul<&Matrix> for &Vector {
421    type Output = Vector;
422    fn mul(self, matrix: &Matrix) -> Self::Output {
423        let mut output = Vector::zero(matrix.width());
424        self.iter()
425            .zip(matrix.iter())
426            .for_each(|(self_i, matrix_i)| {
427                output
428                    .iter_mut()
429                    .zip(matrix_i.iter())
430                    .for_each(|(output_j, matrix_ij)| *output_j += self_i * matrix_ij)
431            });
432        output
433    }
434}
435
436impl<const D: usize, const I: usize> Mul<&TensorRank1Vec<D, I>> for &Vector {
437    type Output = Scalar;
438    fn mul(self, tensor_rank_1_vec: &TensorRank1Vec<D, I>) -> Self::Output {
439        tensor_rank_1_vec
440            .iter()
441            .enumerate()
442            .map(|(a, entry_a)| {
443                entry_a
444                    .iter()
445                    .enumerate()
446                    .map(|(i, entry_a_i)| self[D * a + i] * entry_a_i)
447                    .sum::<Scalar>()
448            })
449            .sum()
450    }
451}
452
453impl<const D: usize, const I: usize, const J: usize> Mul<&TensorRank2<D, I, J>> for &Vector {
454    type Output = Scalar;
455    fn mul(self, tensor_rank_2: &TensorRank2<D, I, J>) -> Self::Output {
456        tensor_rank_2
457            .iter()
458            .enumerate()
459            .map(|(i, entry_i)| {
460                entry_i
461                    .iter()
462                    .enumerate()
463                    .map(|(j, entry_ij)| self[D * i + j] * entry_ij)
464                    .sum::<Scalar>()
465            })
466            .sum()
467    }
468}
conspire/math/matrix/vector/mod.rs

conspire/math/matrix/vector/
mod.rs
