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

conspire/math/matrix/vector/
mod.rs
