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 reserve(&mut self, additional: usize) {
258        self.0.reserve(additional)
259    }
260    fn retain<F>(&mut self, f: F)
261    where
262        F: FnMut(&Self::Item) -> bool,
263    {
264        self.0.retain(f)
265    }
266    fn swap_remove(&mut self, index: usize) -> Self::Item {
267        self.0.swap_remove(index)
268    }
269}
270
271impl<T> Div<TensorRank0> for TensorVector<T>
272where
273    T: Tensor,
274{
275    type Output = Self;
276    fn div(mut self, tensor_rank_0: TensorRank0) -> Self::Output {
277        self /= tensor_rank_0;
278        self
279    }
280}
281
282impl<T> Div<&TensorRank0> for TensorVector<T>
283where
284    T: Tensor,
285{
286    type Output = Self;
287    fn div(mut self, tensor_rank_0: &TensorRank0) -> Self::Output {
288        self /= tensor_rank_0;
289        self
290    }
291}
292
293impl<T> DivAssign<TensorRank0> for TensorVector<T>
294where
295    T: Tensor,
296{
297    fn div_assign(&mut self, tensor_rank_0: TensorRank0) {
298        self.iter_mut().for_each(|entry| *entry /= &tensor_rank_0);
299    }
300}
301
302impl<T> DivAssign<&TensorRank0> for TensorVector<T>
303where
304    T: Tensor,
305{
306    fn div_assign(&mut self, tensor_rank_0: &TensorRank0) {
307        self.iter_mut().for_each(|entry| *entry /= tensor_rank_0);
308    }
309}
310
311impl<T> Mul<TensorRank0> for TensorVector<T>
312where
313    T: Tensor,
314{
315    type Output = Self;
316    fn mul(mut self, tensor_rank_0: TensorRank0) -> Self::Output {
317        self *= tensor_rank_0;
318        self
319    }
320}
321
322impl<T> Mul<&TensorRank0> for TensorVector<T>
323where
324    T: Tensor,
325{
326    type Output = Self;
327    fn mul(mut self, tensor_rank_0: &TensorRank0) -> Self::Output {
328        self *= tensor_rank_0;
329        self
330    }
331}
332
333impl<T> Mul<TensorRank0> for &TensorVector<T>
334where
335    T: Tensor,
336    for<'a> &'a T: Mul<&'a TensorRank0, Output = T>,
337{
338    type Output = TensorVector<T>;
339    fn mul(self, tensor_rank_0: TensorRank0) -> Self::Output {
340        self.iter().map(|self_i| self_i * &tensor_rank_0).collect()
341    }
342}
343
344// impl<T> Mul<&TensorRank0> for &TensorVector<T>
345// where
346//     T: Tensor,
347//     for <'a> &'a T: Mul<&'a TensorRank0, Output=T>
348// {
349//     type Output = TensorVector<T>;
350//     fn mul(self, tensor_rank_0: &TensorRank0) -> Self::Output {
351//         self.iter().map(|self_i| self_i * tensor_rank_0).collect()
352//     }
353// }
354
355impl<T> MulAssign<TensorRank0> for TensorVector<T>
356where
357    T: Tensor,
358{
359    fn mul_assign(&mut self, tensor_rank_0: TensorRank0) {
360        self.iter_mut().for_each(|entry| *entry *= &tensor_rank_0);
361    }
362}
363
364impl<T> MulAssign<&TensorRank0> for TensorVector<T>
365where
366    T: Tensor,
367{
368    fn mul_assign(&mut self, tensor_rank_0: &TensorRank0) {
369        self.iter_mut().for_each(|entry| *entry *= tensor_rank_0);
370    }
371}
372
373impl<T> Add for TensorVector<T>
374where
375    T: Tensor,
376{
377    type Output = Self;
378    fn add(mut self, tensor_vec: Self) -> Self::Output {
379        self += tensor_vec;
380        self
381    }
382}
383
384impl<T> Add<&Self> for TensorVector<T>
385where
386    T: Tensor,
387{
388    type Output = Self;
389    fn add(mut self, tensor_vec: &Self) -> Self::Output {
390        self += tensor_vec;
391        self
392    }
393}
394
395impl<T> AddAssign for TensorVector<T>
396where
397    T: Tensor,
398{
399    fn add_assign(&mut self, tensor_vec: Self) {
400        self.iter_mut()
401            .zip(tensor_vec)
402            .for_each(|(self_entry, entry)| *self_entry += entry);
403    }
404}
405
406impl<T> AddAssign<&Self> for TensorVector<T>
407where
408    T: Tensor,
409{
410    fn add_assign(&mut self, tensor_vec: &Self) {
411        self.iter_mut()
412            .zip(tensor_vec.iter())
413            .for_each(|(self_entry, entry)| *self_entry += entry);
414    }
415}
416
417impl<T> Sub for TensorVector<T>
418where
419    T: Tensor,
420{
421    type Output = Self;
422    fn sub(mut self, tensor_vec: Self) -> Self::Output {
423        self -= tensor_vec;
424        self
425    }
426}
427
428impl<T> Sub<&Self> for TensorVector<T>
429where
430    T: Tensor,
431{
432    type Output = Self;
433    fn sub(mut self, tensor_vec: &Self) -> Self::Output {
434        self -= tensor_vec;
435        self
436    }
437}
438
439impl<T> Sub for &TensorVector<T>
440where
441    T: Tensor,
442    // for <'a> &'a T: Sub<&'a T, Output=T>
443{
444    type Output = TensorVector<T>;
445    fn sub(self, _tensor_vec: Self) -> Self::Output {
446        unimplemented!()
447        // self
448        //     .iter()
449        //     .zip(tensor_vec.iter())
450        //     .map(|(self_entry, entry)| {
451        //         self_entry - entry
452        //     })
453        //     .collect()
454    }
455}
456
457impl<T> SubAssign for TensorVector<T>
458where
459    T: Tensor,
460{
461    fn sub_assign(&mut self, tensor_vec: Self) {
462        self.iter_mut()
463            .zip(tensor_vec)
464            .for_each(|(self_entry, entry)| *self_entry -= entry);
465    }
466}
467
468impl<T> SubAssign<&Self> for TensorVector<T>
469where
470    T: Tensor,
471{
472    fn sub_assign(&mut self, tensor_vec: &Self) {
473        self.iter_mut()
474            .zip(tensor_vec.iter())
475            .for_each(|(self_entry, entry)| *self_entry -= entry);
476    }
477}
conspire/math/tensor/vec/mod.rs

conspire/math/tensor/vec/
mod.rs
