conspire/math/tensor/vec/
mod.rs

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

conspire/math/tensor/vec/
mod.rs
