conspire/math/tensor/vec/
mod.rs

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

conspire/math/tensor/vec/
mod.rs
