conspire/math/tensor/vec/
mod.rs

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

conspire/math/tensor/vec/
mod.rs
