conspire/math/tensor/vec/
mod.rs

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

conspire/math/tensor/vec/
mod.rs
