rstsr_core/tensor/
asarray.rs

1//! Implementation of function `asarray`.
2
3use crate::prelude_dev::*;
4use core::mem::ManuallyDrop;
5use num::complex::{Complex32, Complex64};
6
7/// Trait for function [`asarray`] impl: converting the input to an array.
8///
9/// This trait can be implemented for different backends. For usual CPU backends, we refer to
10/// function [`asarray`] for API documentation details.
11pub trait AsArrayAPI<Inp> {
12    type Out;
13
14    fn asarray_f(self) -> Result<Self::Out>;
15
16    fn asarray(self) -> Self::Out
17    where
18        Self: Sized,
19    {
20        Self::asarray_f(self).rstsr_unwrap()
21    }
22}
23
24/// Convert the input to an array.
25///
26/// **This function is overloaded.**
27///
28/// <div class="warning">
29///
30/// **Row/Column Major Notice**
31///
32/// When passing shape into this function, the layout of output tensor will be different on default
33/// orders ([`RowMajor`] and [`ColMajor`]) of device.
34///
35/// </div>
36///
37/// Note that this function always returns a dynamic-dimensional ([`IxD`]) tensor. To convert it
38/// into a fixed-dimensional tensor, you can use [`.into_dim::<D>()`](Tensor::into_dim) method on
39/// the output tensor without explicit data copy.
40///
41/// # Overloads Table
42///
43/// ## Output owned tensor [`Tensor`]
44///
45/// Input vector [`Vec<T>`] as raw data:
46///
47/// - `asarray((input: Vec<T>, layout: Layout<D>, device: &B)) -> Tensor<T, B, IxD>`
48/// - `asarray((input: Vec<T>, shape: D, device: &B)) -> Tensor<T, B, IxD>`
49/// - `asarray((input: Vec<T>, device: &B)) -> Tensor<T, B, IxD>`
50/// - `asarray((input: Vec<T>, layout: Layout<D>)) -> Tensor<T, DeviceCpu, IxD>`
51/// - `asarray((input: Vec<T>, shape: D)) -> Tensor<T, DeviceCpu, IxD>`
52/// - `asarray(input: Vec<T>) -> Tensor<T, DeviceCpu, IxD>`
53///
54/// Input scalar `T` as raw data:
55///
56/// - `asarray((input: T, device: &B)) -> Tensor<T, B, IxD>`
57/// - `asarray(input: T) -> Tensor<T, DeviceCpu, IxD>`
58///
59/// Input tensor as raw data and change its layout:
60///
61/// - `asarray((input: &TensorAny<R, T, B, D>, order: TensorIterOrder)) -> Tensor<T, B, D>`
62/// - `asarray((input: TensorView<'_, T, B, D>, order: TensorIterOrder)) -> Tensor<T, B, D>`
63/// - `asarray((input: Tensor<T, B, D>, order: TensorIterOrder)) -> Tensor<T, B, D>`
64/// - `asarray(input: &TensorAny<R, T, B, D>) -> Tensor<T, B, D>`
65/// - `asarray(input: TensorView<'_, T, B, D>) -> Tensor<T, B, D>`
66/// - `asarray(input: Tensor<T, B, D>) -> Tensor<T, B, D>`
67///
68/// ## Output tensor view [`TensorView`]
69///
70/// - `asarray((input: &[T], layout: Layout<D>, device: &B)) -> TensorView<'a, T, B, IxD>`
71/// - `asarray((input: &[T], shape: D, device: &B)) -> TensorView<'a, T, B, IxD>`
72/// - `asarray((input: &[T], device: &B)) -> TensorView<'a, T, B, IxD>`
73/// - `asarray((input: &[T], layout: Layout<D>)) -> TensorView<'a, T, DeviceCpu, IxD>`
74/// - `asarray((input: &[T], shape: D)) -> TensorView<'a, T, DeviceCpu, IxD>`
75/// - `asarray(input: &[T]) -> TensorView<'a, T, DeviceCpu, IxD>`
76///
77/// Also, overloads for `&Vec<T>` that behave the same as `&[T]`.
78///
79/// ## Output mutable tensor view [`TensorMut`]
80///
81/// All overloads for `&[T]` and `&Vec<T>` above also have mutable versions for `&mut [T]` and `&mut
82/// Vec<T>`, which output [`TensorMut<'a, T, B, IxD>`] and [`TensorMut<'a, T, DeviceCpu, IxD>`],
83/// respectively.
84///
85/// # Examples
86///
87/// ## Vector as input
88///
89/// The most usual usage is to convert a vector into a tensor. You can also specify the shape /
90/// layout and device.
91///
92/// **The following example assumes that the device's default order is row-major**. The input shape
93/// `[2, 3]` corresponds to a row-major layout `[2, 3].c()`.
94///
95/// ```rust
96/// use rstsr::prelude::*;
97/// let mut device = DeviceCpu::default();
98/// device.set_default_order(RowMajor);
99///
100/// // vector as input, row-major layout by default
101/// let input = vec![1, 2, 3, 4, 5, 6];
102/// let a = rt::asarray((input, [2, 3], &device));
103/// println!("{a:?}");
104/// // [[1, 2, 3],
105/// //  [4, 5, 6]]
106/// // 2-Dim (dyn), contiguous: Cc, shape: [2, 3], stride: [3, 1], offset: 0
107/// # let expected = rt::tensor_from_nested!([[1, 2, 3], [4, 5, 6]], &device);
108/// # assert!(rt::allclose(&a, &expected, None));
109/// ```
110///
111/// If you want to use column-major layout, you can specify the layout explicitly. But be cautious
112/// that **row-major and column-major layouts will lead to different arrangements of data**.
113///
114/// ```rust
115/// # use rstsr::prelude::*;
116/// # let mut device = DeviceCpu::default();
117/// # device.set_default_order(RowMajor);
118/// // vector as input, column-major layout
119/// let input = vec![1, 2, 3, 4, 5, 6];
120/// let a = rt::asarray((input, [2, 3].f(), &device));
121/// println!("{a:?}");
122/// // [[ 1 3 5]
123/// //  [ 2 4 6]]
124/// // 2-Dim (dyn), contiguous: Ff, shape: [2, 3], stride: [1, 2], offset: 0
125/// # let expected = rt::tensor_from_nested!([[1, 3, 5], [2, 4, 6]], &device);
126/// # assert!(rt::allclose(&a, &expected, None));
127/// ```
128///
129/// Also, **if the device's default order is column-major**, the shape input (`[2, 3]`) will also
130/// lead to a column-major layout (`[2, 3].f()`):
131///
132/// ```rust
133/// # use rstsr::prelude::*;
134/// # let mut device = DeviceCpu::default();
135/// # device.set_default_order(RowMajor);
136/// // vector as input, column layout by default
137/// device.set_default_order(ColMajor);
138/// let input = vec![1, 2, 3, 4, 5, 6];
139/// let a = rt::asarray((input, [2, 3], &device));
140/// println!("{a:?}");
141/// // [[ 1 3 5]
142/// //  [ 2 4 6]]
143/// // 2-Dim (dyn), contiguous: Ff, shape: [2, 3], stride: [1, 2], offset: 0
144/// # let expected = rt::tensor_from_nested!([[1, 3, 5], [2, 4, 6]], &device);
145/// # assert!(rt::allclose(&a, &expected, None));
146/// ```
147///
148/// Finally, you can omit the device argument to use the default CPU device, and omit the
149/// layout/shape to get an 1-D tensor:
150///
151/// ```rust
152/// # use rstsr::prelude::*;
153/// # let mut device = DeviceCpu::default();
154/// # device.set_default_order(RowMajor);
155/// let input = vec![1, 2, 3, 4, 5, 6];
156/// let a = rt::asarray(input);;
157/// println!("{a:?}");
158/// // [ 1 2 3 4 5 6]
159/// // 1-Dim (dyn), contiguous: Cc, shape: [6], stride: [1], offset: 0
160/// # let expected = rt::tensor_from_nested!([1, 2, 3, 4, 5, 6]);
161/// # assert!(rt::allclose(&a, &expected, None));
162/// ```
163///
164/// ## `&[T]` or `&mut [T]` as input
165///
166/// You can also convert a slice into a tensor view. Please note, `asarray` accepts `&[T]` and
167/// `&Vec<T>`, but do not accept other slice-like types such as `&[T; N]`. You may need to convert
168/// them by `.as_ref()` first.
169///
170/// ```rust
171/// # use rstsr::prelude::*;
172/// # let mut device = DeviceCpu::default();
173/// # device.set_default_order(RowMajor);
174/// // Slice &[T] as input
175/// let input = &[1, 2, 3, 4, 5, 6];
176/// let a = rt::asarray((input.as_ref(), [2, 3].c(), &device));
177/// println!("{a:?}");
178/// // [[ 1 2 3]
179/// //  [ 4 5 6]]
180/// # let expected = rt::tensor_from_nested!([[1, 2, 3], [4, 5, 6]], &device);
181/// # assert!(rt::allclose(&a, &expected, None));
182/// ```
183///
184/// Also, mutable slices `&mut [T]` and `&mut Vec<T>` are supported. You can modify the original
185/// data via the output tensor mutable view.
186///
187/// ```rust
188/// # use rstsr::prelude::*;
189/// # let mut device = DeviceCpu::default();
190/// # device.set_default_order(RowMajor);
191/// // Slice &mut [T] as input
192/// let mut input = vec![1, 2, 3, 4, 5, 6];
193/// let mut a = rt::asarray((&mut input, [2, 3].c(), &device));
194/// // change `input` via tensor view `a`
195/// a[[0, 0]] = 10;
196/// println!("{a:2?}");
197/// // [[ 10  2  3]
198/// //  [  4  5  6]]
199/// # let expected = rt::tensor_from_nested!([[10, 2, 3], [4, 5, 6]], &device);
200/// # assert!(rt::allclose(&a, &expected, None));
201/// println!("{input:?}");
202/// // [10, 2, 3, 4, 5, 6]
203/// # assert_eq!(input, vec![10, 2, 3, 4, 5, 6]);
204/// ```
205///
206/// You can also specify a sub-view via layout:
207///
208/// ```rust
209/// # use rstsr::prelude::*;
210/// # let mut device = DeviceCpu::default();
211/// # device.set_default_order(RowMajor);
212/// let input = (0..30).collect::<Vec<i32>>();
213/// let layout = Layout::new([3, 2], [2, 7], 5).unwrap();
214/// let a = rt::asarray((&input, layout, &device));
215/// println!("{a:2?}");
216/// // [[  5 12]
217/// //  [  7 14]
218/// //  [  9 16]]
219/// # let expected = rt::tensor_from_nested!([[5, 12], [7, 14], [9, 16]], &device);
220/// # assert!(rt::allclose(&a, &expected, None));
221/// ```
222///
223/// Finally, you can also omit the device argument to use the default CPU device.
224///
225/// ## Scalar as input
226///
227/// You can also convert a scalar into a tensor with zero dimensions.
228///
229/// ```rust
230/// # use rstsr::prelude::*;
231/// # let mut device = DeviceCpu::default();
232/// # device.set_default_order(RowMajor);
233/// let a = rt::asarray((42, &device));
234/// println!("{a:?}");
235/// // 42
236/// // 0-Dim (dyn), contiguous: CcFf, shape: [], stride: [], offset: 0
237/// ```
238///
239/// ## Tensor or its view as input
240///
241/// You can convert a tensor or its view into a new tensor with specified iteration order (layout).
242///
243/// This is similar to the optional argument `order` in NumPy's `np.asarray` function. The converted
244/// tensor behaves exactly the same to the input tensor, but may have different memory layout.
245///
246/// To specify the order, you may pass [`TensorIterOrder`] along with the input tensor:
247/// - [`TensorIterOrder::K`] for keeping the original layout as much as possible;
248/// - [`TensorIterOrder::C`] for row-major layout;
249/// - [`TensorIterOrder::F`] for column-major layout.
250///
251/// ```rust
252/// # use rstsr::prelude::*;
253/// # let mut device = DeviceCpu::default();
254/// # device.set_default_order(RowMajor);
255/// // Generate a strided, non-row-or-col-prefer tensor view
256/// let a_raw = rt::arange((96, &device)).into_shape([4, 6, 4]);
257/// let a = a_raw.i((..2, slice!(2, 6, 2), 2..)).into_transpose([1, 0, 2]);
258/// println!("{a:2?}");
259/// // [[[10, 11], [34, 35]], [[18, 19], [42, 43]]]
260/// // shape: [2, 2, 2], stride: [8, 24, 1], offset: 10
261/// # let expected = rt::tensor_from_nested!([[[10, 11], [34, 35]], [[18, 19], [42, 43]]], &device);
262/// # assert!(rt::allclose(&a, &expected, None));
263///
264/// // shrink useful memory space, with preserved layout
265/// let b = rt::asarray((&a, TensorIterOrder::K));
266/// println!("{b:2?}");
267/// // shape: [2, 2, 2], stride: [2, 4, 1], offset: 0
268/// # assert!(rt::allclose(&b, &expected, None));
269/// # assert_eq!(b.stride(), &[2, 4, 1]);
270///
271/// // convert to row-major layout
272/// let b = rt::asarray((&a, TensorIterOrder::C));
273/// println!("{b:2?}");
274/// // shape: [2, 2, 2], stride: [4, 2, 1], offset: 0
275/// # assert!(rt::allclose(&b, &expected, None));
276/// # assert_eq!(b.stride(), &[4, 2, 1]);
277///
278/// // convert to column-major layout
279/// let b = rt::asarray((&a, TensorIterOrder::F));
280/// println!("{b:2?}");
281/// // shape: [2, 2, 2], stride: [1, 2, 4], offset: 0
282/// # assert!(rt::allclose(&b, &expected, None));
283/// # assert_eq!(b.stride(), &[1, 2, 4]);
284/// ```
285///
286/// # See also
287///
288/// ## Similar function from other crates/libraries
289///
290/// - [`numpy.asarray`](https://numpy.org/doc/stable/reference/generated/numpy.asarray.html)
291///
292/// ## Related functions in RSTSR
293///
294/// - [`tensor_from_nested`]: Create a tensor from nested array-like data (for debug usage, only).
295/// - [`Tensor::new`] or [`Tensor::new_unchecked`]: Create a tensor from storage and layout.
296///
297/// ## Variants of this function
298///
299/// - [`asarray_f`]: Fallible version of this function.
300pub fn asarray<Args, Inp>(param: Args) -> Args::Out
301where
302    Args: AsArrayAPI<Inp>,
303{
304    return AsArrayAPI::asarray(param);
305}
306
307/// Convert the input to an array.
308///
309/// # See also
310///
311/// Refer to [`asarray`] for more details and examples.
312pub fn asarray_f<Args, Inp>(param: Args) -> Result<Args::Out>
313where
314    Args: AsArrayAPI<Inp>,
315{
316    return AsArrayAPI::asarray_f(param);
317}
318
319/* #region tensor input */
320
321impl<R, T, B, D> AsArrayAPI<()> for (&TensorAny<R, T, B, D>, TensorIterOrder)
322where
323    R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>,
324    T: Clone,
325    D: DimAPI,
326    B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,
327{
328    type Out = Tensor<T, B, D>;
329
330    fn asarray_f(self) -> Result<Self::Out> {
331        let (input, order) = self;
332        let device = input.device();
333        let layout_a = input.layout();
334        let layout_c = layout_for_array_copy(layout_a, order)?;
335        let mut storage_c = device.uninit_impl(layout_c.size())?;
336        device.assign_uninit(storage_c.raw_mut(), &layout_c, input.raw(), layout_a)?;
337        let storage_c = unsafe { B::assume_init_impl(storage_c) }?;
338        let tensor = Tensor::new_f(storage_c, layout_c)?;
339        return Ok(tensor);
340    }
341}
342
343impl<R, T, B, D> AsArrayAPI<()> for &TensorAny<R, T, B, D>
344where
345    R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>,
346    T: Clone,
347    D: DimAPI,
348    B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,
349{
350    type Out = Tensor<T, B, D>;
351
352    fn asarray_f(self) -> Result<Self::Out> {
353        asarray_f((self, TensorIterOrder::default()))
354    }
355}
356
357impl<T, B, D> AsArrayAPI<()> for (Tensor<T, B, D>, TensorIterOrder)
358where
359    T: Clone,
360    D: DimAPI,
361    B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,
362{
363    type Out = Tensor<T, B, D>;
364
365    fn asarray_f(self) -> Result<Self::Out> {
366        let (input, order) = self;
367        let storage_a = input.storage();
368        let layout_a = input.layout();
369        let device = storage_a.device();
370        let layout_c = layout_for_array_copy(layout_a, order)?;
371        if layout_c == *layout_a {
372            return Ok(input);
373        } else {
374            let mut storage_c = device.uninit_impl(layout_c.size())?;
375            device.assign_uninit(storage_c.raw_mut(), &layout_c, storage_a.raw(), layout_a)?;
376            let storage_c = unsafe { B::assume_init_impl(storage_c) }?;
377            let tensor = Tensor::new_f(storage_c, layout_c)?;
378            return Ok(tensor);
379        }
380    }
381}
382
383impl<T, B, D> AsArrayAPI<()> for Tensor<T, B, D>
384where
385    T: Clone,
386    D: DimAPI,
387    B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,
388{
389    type Out = Tensor<T, B, D>;
390
391    fn asarray_f(self) -> Result<Self::Out> {
392        asarray_f((self, TensorIterOrder::default()))
393    }
394}
395
396impl<T, B, D> AsArrayAPI<()> for (TensorView<'_, T, B, D>, TensorIterOrder)
397where
398    T: Clone,
399    D: DimAPI,
400    B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,
401{
402    type Out = Tensor<T, B, D>;
403
404    fn asarray_f(self) -> Result<Self::Out> {
405        let (input, order) = self;
406        asarray_f((&input, order))
407    }
408}
409
410impl<T, B, D> AsArrayAPI<()> for TensorView<'_, T, B, D>
411where
412    T: Clone,
413    D: DimAPI,
414    B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,
415{
416    type Out = Tensor<T, B, D>;
417
418    fn asarray_f(self) -> Result<Self::Out> {
419        asarray_f((self, TensorIterOrder::default()))
420    }
421}
422
423/* #endregion */
424
425/* #region vec-like input */
426
427impl<T, B> AsArrayAPI<()> for (Vec<T>, &B)
428where
429    B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,
430{
431    type Out = Tensor<T, B, IxD>;
432
433    fn asarray_f(self) -> Result<Self::Out> {
434        let (input, device) = self;
435        let layout = vec![input.len()].c();
436        let storage = device.outof_cpu_vec(input)?;
437        let tensor = Tensor::new_f(storage, layout)?;
438        return Ok(tensor);
439    }
440}
441
442impl<T, B, D> AsArrayAPI<D> for (Vec<T>, Layout<D>, &B)
443where
444    D: DimAPI,
445    B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,
446{
447    type Out = Tensor<T, B, IxD>;
448
449    fn asarray_f(self) -> Result<Self::Out> {
450        let (input, layout, device) = self;
451        let storage = device.outof_cpu_vec(input)?;
452        let tensor = Tensor::new_f(storage, layout.into_dim()?)?;
453        return Ok(tensor);
454    }
455}
456
457impl<T, B, D> AsArrayAPI<D> for (Vec<T>, D, &B)
458where
459    D: DimAPI,
460    B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,
461{
462    type Out = Tensor<T, B, IxD>;
463
464    fn asarray_f(self) -> Result<Self::Out> {
465        let (input, shape, device) = self;
466        let default_order = device.default_order();
467        let layout = match default_order {
468            RowMajor => shape.c(),
469            ColMajor => shape.f(),
470        };
471        asarray_f((input, layout, device))
472    }
473}
474
475impl<T> AsArrayAPI<()> for Vec<T>
476where
477    T: Clone,
478{
479    type Out = Tensor<T, DeviceCpu, IxD>;
480
481    fn asarray_f(self) -> Result<Self::Out> {
482        asarray_f((self, &DeviceCpu::default()))
483    }
484}
485
486#[duplicate_item(L; [D]; [Layout<D>])]
487impl<T, D> AsArrayAPI<D> for (Vec<T>, L)
488where
489    T: Clone,
490    D: DimAPI,
491{
492    type Out = Tensor<T, DeviceCpu, IxD>;
493
494    fn asarray_f(self) -> Result<Self::Out> {
495        let (input, layout) = self;
496        asarray_f((input, layout, &DeviceCpu::default()))
497    }
498}
499
500impl<T> From<Vec<T>> for Tensor<T, DeviceCpu, IxD>
501where
502    T: Clone,
503{
504    fn from(input: Vec<T>) -> Self {
505        asarray_f(input).rstsr_unwrap()
506    }
507}
508
509/* #endregion */
510
511/* #region slice-like input */
512
513impl<'a, T, B, D> AsArrayAPI<D> for (&'a [T], Layout<D>, &B)
514where
515    T: Clone,
516    B: DeviceAPI<T, Raw = Vec<T>>,
517    D: DimAPI,
518{
519    type Out = TensorView<'a, T, B, IxD>;
520
521    fn asarray_f(self) -> Result<Self::Out> {
522        let (input, layout, device) = self;
523        let ptr = input.as_ptr();
524        let len = input.len();
525        let raw = unsafe {
526            let ptr = ptr as *mut T;
527            Vec::from_raw_parts(ptr, len, len)
528        };
529        let device = device.clone();
530        let data = DataRef::from_manually_drop(ManuallyDrop::new(raw));
531        let storage = Storage::new(data, device);
532        let tensor = TensorView::new_f(storage, layout.into_dim()?)?;
533        return Ok(tensor);
534    }
535}
536
537impl<'a, T, B, D> AsArrayAPI<D> for (&'a [T], D, &B)
538where
539    T: Clone,
540    B: DeviceAPI<T, Raw = Vec<T>>,
541    D: DimAPI,
542{
543    type Out = TensorView<'a, T, B, IxD>;
544
545    fn asarray_f(self) -> Result<Self::Out> {
546        let (input, shape, device) = self;
547        let default_order = device.default_order();
548        let layout = match default_order {
549            RowMajor => shape.c(),
550            ColMajor => shape.f(),
551        };
552        asarray_f((input, layout, device))
553    }
554}
555
556impl<'a, T, B> AsArrayAPI<()> for (&'a [T], &B)
557where
558    T: Clone,
559    B: DeviceAPI<T, Raw = Vec<T>>,
560{
561    type Out = TensorView<'a, T, B, IxD>;
562
563    fn asarray_f(self) -> Result<Self::Out> {
564        let (input, device) = self;
565        let layout = vec![input.len()].c();
566        let device = device.clone();
567
568        let ptr = input.as_ptr();
569        let len = input.len();
570        let raw = unsafe {
571            let ptr = ptr as *mut T;
572            Vec::from_raw_parts(ptr, len, len)
573        };
574        let data = DataRef::from_manually_drop(ManuallyDrop::new(raw));
575        let storage = Storage::new(data, device);
576        let tensor = TensorView::new_f(storage, layout)?;
577        return Ok(tensor);
578    }
579}
580
581#[duplicate_item(L; [D]; [Layout<D>])]
582impl<'a, T, D> AsArrayAPI<D> for (&'a [T], L)
583where
584    T: Clone,
585    D: DimAPI,
586{
587    type Out = TensorView<'a, T, DeviceCpu, IxD>;
588
589    fn asarray_f(self) -> Result<Self::Out> {
590        let (input, layout) = self;
591        asarray_f((input, layout, &DeviceCpu::default()))
592    }
593}
594
595impl<'a, T> AsArrayAPI<()> for &'a [T]
596where
597    T: Clone,
598{
599    type Out = TensorView<'a, T, DeviceCpu, IxD>;
600
601    fn asarray_f(self) -> Result<Self::Out> {
602        asarray_f((self, &DeviceCpu::default()))
603    }
604}
605
606#[duplicate_item(L; [D]; [Layout<D>])]
607impl<'a, T, B, D> AsArrayAPI<D> for (&'a Vec<T>, L, &B)
608where
609    T: Clone,
610    B: DeviceAPI<T, Raw = Vec<T>> + 'a,
611    D: DimAPI,
612{
613    type Out = TensorView<'a, T, B, IxD>;
614
615    fn asarray_f(self) -> Result<Self::Out> {
616        let (input, layout, device) = self;
617        asarray_f((input.as_slice(), layout, device))
618    }
619}
620
621impl<'a, T, B> AsArrayAPI<()> for (&'a Vec<T>, &B)
622where
623    T: Clone,
624    B: DeviceAPI<T, Raw = Vec<T>>,
625{
626    type Out = TensorView<'a, T, B, IxD>;
627
628    fn asarray_f(self) -> Result<Self::Out> {
629        let (input, device) = self;
630        asarray_f((input.as_slice(), device))
631    }
632}
633
634#[duplicate_item(L; [D]; [Layout<D>])]
635impl<'a, T, D> AsArrayAPI<D> for (&'a Vec<T>, L)
636where
637    T: Clone,
638    D: DimAPI,
639{
640    type Out = TensorView<'a, T, DeviceCpu, IxD>;
641
642    fn asarray_f(self) -> Result<Self::Out> {
643        let (input, layout) = self;
644        asarray_f((input.as_slice(), layout, &DeviceCpu::default()))
645    }
646}
647
648impl<'a, T> AsArrayAPI<()> for &'a Vec<T>
649where
650    T: Clone,
651{
652    type Out = TensorView<'a, T, DeviceCpu, IxD>;
653
654    fn asarray_f(self) -> Result<Self::Out> {
655        asarray_f((self.as_slice(), &DeviceCpu::default()))
656    }
657}
658
659impl<'a, T> From<&'a [T]> for TensorView<'a, T, DeviceCpu, IxD>
660where
661    T: Clone,
662{
663    fn from(input: &'a [T]) -> Self {
664        asarray(input)
665    }
666}
667
668impl<'a, T> From<&'a Vec<T>> for TensorView<'a, T, DeviceCpu, IxD>
669where
670    T: Clone,
671{
672    fn from(input: &'a Vec<T>) -> Self {
673        asarray(input)
674    }
675}
676
677/* #endregion */
678
679/* #region slice-like mutable input */
680
681impl<'a, T, B, D> AsArrayAPI<D> for (&'a mut [T], Layout<D>, &B)
682where
683    T: Clone,
684    B: DeviceAPI<T, Raw = Vec<T>>,
685    D: DimAPI,
686{
687    type Out = TensorMut<'a, T, B, IxD>;
688
689    fn asarray_f(self) -> Result<Self::Out> {
690        let (input, layout, device) = self;
691        let ptr = input.as_ptr();
692        let len = input.len();
693        let raw = unsafe {
694            let ptr = ptr as *mut T;
695            Vec::from_raw_parts(ptr, len, len)
696        };
697        let device = device.clone();
698        let data = DataMut::from_manually_drop(ManuallyDrop::new(raw));
699        let storage = Storage::new(data, device);
700        let tensor = TensorMut::new_f(storage, layout.into_dim()?)?;
701        return Ok(tensor);
702    }
703}
704
705impl<'a, T, B, D> AsArrayAPI<D> for (&'a mut [T], D, &B)
706where
707    T: Clone,
708    B: DeviceAPI<T, Raw = Vec<T>>,
709    D: DimAPI,
710{
711    type Out = TensorMut<'a, T, B, IxD>;
712
713    fn asarray_f(self) -> Result<Self::Out> {
714        let (input, shape, device) = self;
715        let default_order = device.default_order();
716        let layout = match default_order {
717            RowMajor => shape.c(),
718            ColMajor => shape.f(),
719        };
720        asarray_f((input, layout, device))
721    }
722}
723
724impl<'a, T, B> AsArrayAPI<()> for (&'a mut [T], &B)
725where
726    T: Clone,
727    B: DeviceAPI<T, Raw = Vec<T>>,
728{
729    type Out = TensorMut<'a, T, B, IxD>;
730
731    fn asarray_f(self) -> Result<Self::Out> {
732        let (input, device) = self;
733        let layout = [input.len()].c();
734        let device = device.clone();
735
736        let ptr = input.as_ptr();
737        let len = input.len();
738        let raw = unsafe {
739            let ptr = ptr as *mut T;
740            Vec::from_raw_parts(ptr, len, len)
741        };
742        let data = DataMut::from_manually_drop(ManuallyDrop::new(raw));
743        let storage = Storage::new(data, device);
744        let tensor = TensorMut::new_f(storage, layout.into_dim()?)?;
745        return Ok(tensor);
746    }
747}
748
749#[duplicate_item(L; [D]; [Layout<D>])]
750impl<'a, T, D> AsArrayAPI<D> for (&'a mut [T], L)
751where
752    T: Clone,
753    D: DimAPI,
754{
755    type Out = TensorMut<'a, T, DeviceCpu, IxD>;
756
757    fn asarray_f(self) -> Result<Self::Out> {
758        let (input, layout) = self;
759        asarray_f((input, layout, &DeviceCpu::default()))
760    }
761}
762
763impl<'a, T> AsArrayAPI<()> for &'a mut [T]
764where
765    T: Clone,
766{
767    type Out = TensorMut<'a, T, DeviceCpu, IxD>;
768
769    fn asarray_f(self) -> Result<Self::Out> {
770        asarray_f((self, &DeviceCpu::default()))
771    }
772}
773
774#[duplicate_item(L; [D]; [Layout<D>])]
775impl<'a, T, B, D> AsArrayAPI<D> for (&'a mut Vec<T>, L, &B)
776where
777    T: Clone,
778    B: DeviceAPI<T, Raw = Vec<T>>,
779    D: DimAPI,
780{
781    type Out = TensorMut<'a, T, B, IxD>;
782
783    fn asarray_f(self) -> Result<Self::Out> {
784        let (input, layout, device) = self;
785        asarray_f((input.as_mut_slice(), layout, device))
786    }
787}
788
789impl<'a, T, B> AsArrayAPI<()> for (&'a mut Vec<T>, &B)
790where
791    T: Clone,
792    B: DeviceAPI<T, Raw = Vec<T>>,
793{
794    type Out = TensorMut<'a, T, B, IxD>;
795
796    fn asarray_f(self) -> Result<Self::Out> {
797        let (input, device) = self;
798        asarray_f((input.as_mut_slice(), device))
799    }
800}
801
802#[duplicate_item(L; [D]; [Layout<D>])]
803impl<'a, T, D> AsArrayAPI<D> for (&'a mut Vec<T>, L)
804where
805    T: Clone,
806    D: DimAPI,
807{
808    type Out = TensorMut<'a, T, DeviceCpu, IxD>;
809
810    fn asarray_f(self) -> Result<Self::Out> {
811        let (input, layout) = self;
812        asarray_f((input.as_mut_slice(), layout, &DeviceCpu::default()))
813    }
814}
815
816impl<'a, T> AsArrayAPI<()> for &'a mut Vec<T>
817where
818    T: Clone,
819{
820    type Out = TensorMut<'a, T, DeviceCpu, IxD>;
821
822    fn asarray_f(self) -> Result<Self::Out> {
823        asarray_f((self.as_mut_slice(), &DeviceCpu::default()))
824    }
825}
826
827impl<'a, T> From<&'a mut [T]> for TensorMut<'a, T, DeviceCpu, IxD>
828where
829    T: Clone,
830{
831    fn from(input: &'a mut [T]) -> Self {
832        asarray(input)
833    }
834}
835
836impl<'a, T> From<&'a mut Vec<T>> for TensorMut<'a, T, DeviceCpu, IxD>
837where
838    T: Clone,
839{
840    fn from(input: &'a mut Vec<T>) -> Self {
841        asarray(input)
842    }
843}
844
845/* #endregion */
846
847/* #region scalar input */
848
849macro_rules! impl_asarray_scalar {
850    ($($t:ty),*) => {
851        $(
852            impl<B> AsArrayAPI<()> for ($t, &B)
853            where
854                B: DeviceAPI<$t> + DeviceCreationAnyAPI<$t>,
855            {
856                type Out = Tensor<$t, B, IxD>;
857
858                fn asarray_f(self) -> Result<Self::Out> {
859                    let (input, device) = self;
860                    let layout = Layout::new(vec![], vec![], 0)?;
861                    let storage = device.outof_cpu_vec(vec![input])?;
862                    let tensor = unsafe { Tensor::new_unchecked(storage, layout) };
863                    return Ok(tensor);
864                }
865            }
866
867            impl AsArrayAPI<()> for $t {
868                type Out = Tensor<$t, DeviceCpu, IxD>;
869
870                fn asarray_f(self) -> Result<Self::Out> {
871                    asarray_f((self, &DeviceCpu::default()))
872                }
873            }
874        )*
875    };
876}
877
878impl_asarray_scalar!(i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64, Complex32, Complex64);
879
880/* #endregion */
881
882#[cfg(test)]
883mod tests {
884    use super::*;
885
886    #[test]
887    fn test_asarray() {
888        let input = vec![1, 2, 3];
889        let tensor = asarray_f(input).unwrap();
890        println!("{tensor:?}");
891        let input = [1, 2, 3];
892        let tensor = asarray_f(input.as_ref()).unwrap();
893        println!("{tensor:?}");
894
895        let input = vec![1, 2, 3];
896        let tensor = asarray_f(&input).unwrap();
897        println!("{:?}", tensor.raw().as_ptr());
898        println!("{tensor:?}");
899
900        let tensor = asarray_f((&tensor, TensorIterOrder::K)).unwrap();
901        println!("{tensor:?}");
902
903        let tensor = asarray_f((tensor, TensorIterOrder::K)).unwrap();
904        println!("{tensor:?}");
905    }
906
907    #[test]
908    fn test_asarray_scalar() {
909        let tensor = asarray_f(1).unwrap();
910        println!("{tensor:?}");
911        let tensor = asarray_f((Complex64::new(0., 1.), &DeviceCpuSerial::default())).unwrap();
912        println!("{tensor:?}");
913    }
914
915    #[test]
916    fn doc_asarray() {
917        use rstsr::prelude::*;
918        let mut device = DeviceCpu::default();
919        device.set_default_order(RowMajor);
920
921        // vector as input, row-major layout by default
922        let input = vec![1, 2, 3, 4, 5, 6];
923        let a = rt::asarray((input, [2, 3], &device));
924        println!("{a:?}");
925        // [[ 1 2 3]
926        //  [ 4 5 6]]
927        // 2-Dim (dyn), contiguous: Cc, shape: [2, 3], stride: [3, 1], offset: 0
928        let expected = rt::tensor_from_nested!([[1, 2, 3], [4, 5, 6]], &device);
929        assert!(rt::allclose(&a, &expected, None));
930
931        // vector as input, column-major layout
932        let input = vec![1, 2, 3, 4, 5, 6];
933        let a = rt::asarray((input, [2, 3].f(), &device));
934        println!("{a:?}");
935        // [[ 1 3 5]
936        //  [ 2 4 6]]
937        // 2-Dim (dyn), contiguous: Ff, shape: [2, 3], stride: [1, 2], offset: 0
938        let expected = rt::tensor_from_nested!([[1, 3, 5], [2, 4, 6]], &device);
939        assert!(rt::allclose(&a, &expected, None));
940
941        // vector as input, column layout by default
942        device.set_default_order(ColMajor);
943        let input = vec![1, 2, 3, 4, 5, 6];
944        let a = rt::asarray((input, [2, 3], &device));
945        println!("{a:?}");
946        // [[ 1 3 5]
947        //  [ 2 4 6]]
948        // 2-Dim (dyn), contiguous: Ff, shape: [2, 3], stride: [1, 2], offset: 0
949        let expected = rt::tensor_from_nested!([[1, 3, 5], [2, 4, 6]], &device);
950        assert!(rt::allclose(&a, &expected, None));
951
952        // 1-D vector, default CPU device
953        let input = vec![1, 2, 3, 4, 5, 6];
954        let a = rt::asarray(input);
955        println!("{a:?}");
956        // [ 1 2 3 4 5 6]
957        // 1-Dim (dyn), contiguous: Cc, shape: [6], stride: [1], offset: 0
958        let expected = rt::tensor_from_nested!([1, 2, 3, 4, 5, 6]);
959        assert!(rt::allclose(&a, &expected, None));
960
961        // Slice &[T] as input
962        device.set_default_order(RowMajor);
963        let input = &[1, 2, 3, 4, 5, 6];
964        let a = rt::asarray((input.as_ref(), [2, 3].c(), &device));
965        println!("{a:?}");
966        // [[ 1 2 3]
967        //  [ 4 5 6]]
968        let expected = rt::tensor_from_nested!([[1, 2, 3], [4, 5, 6]], &device);
969        assert!(rt::allclose(&a, &expected, None));
970
971        // Slice &mut [T] as input
972        let mut input = vec![1, 2, 3, 4, 5, 6];
973        let mut a = rt::asarray((&mut input, [2, 3].c(), &device));
974        // change `input` via tensor view `a`
975        a[[0, 0]] = 10;
976        println!("{a:2?}");
977        // [[10 2 3]
978        //  [ 4 5 6]]
979        let expected = rt::tensor_from_nested!([[10, 2, 3], [4, 5, 6]], &device);
980        assert!(rt::allclose(&a, &expected, None));
981        println!("{input:?}");
982        // [10, 2, 3, 4, 5, 6]
983        assert_eq!(input, vec![10, 2, 3, 4, 5, 6]);
984
985        // Sub-view from &Vec<T>
986        let input = (0..30).collect::<Vec<i32>>();
987        let layout = Layout::new([3, 2], [2, 7], 5).unwrap();
988        let a = rt::asarray((&input, layout, &device));
989        println!("{a:2?}");
990        // [[  5 12]
991        //  [  7 14]
992        //  [  9 16]]
993        let expected = rt::tensor_from_nested!([[5, 12], [7, 14], [9, 16]], &device);
994        assert!(rt::allclose(&a, &expected, None));
995
996        // Scalar as input
997        let a = rt::asarray((42, &device));
998        println!("{a:?}");
999        // 42
1000        // 0-Dim (dyn), contiguous: CcFf, shape: [], stride: [], offset: 0
1001    }
1002
1003    #[test]
1004    fn doc_asarray_from_tensor() {
1005        use rstsr::prelude::*;
1006        let mut device = DeviceCpu::default();
1007        device.set_default_order(RowMajor);
1008
1009        // Generate a strided, non-row-or-col-prefer tensor view
1010        let a_raw = rt::arange((96, &device)).into_shape([4, 6, 4]);
1011        let a = a_raw.i((..2, slice!(2, 6, 2), 2..)).into_transpose([1, 0, 2]);
1012        println!("{a:2?}");
1013        // [[[10, 11], [34, 35]], [[18, 19], [42, 43]]]
1014        // shape: [2, 2, 2], stride: [8, 24, 1], offset: 10
1015        let expected = rt::tensor_from_nested!([[[10, 11], [34, 35]], [[18, 19], [42, 43]]], &device);
1016        assert!(rt::allclose(&a, &expected, None));
1017        let b = rt::asarray((&a, TensorIterOrder::K));
1018        println!("{b:2?}");
1019        // shape: [2, 2, 2], stride: [2, 4, 1], offset: 0
1020        assert!(rt::allclose(&b, &expected, None));
1021        assert_eq!(b.stride(), &[2, 4, 1]);
1022        let b = rt::asarray((&a, TensorIterOrder::C));
1023        println!("{b:2?}");
1024        // shape: [2, 2, 2], stride: [4, 2, 1], offset: 0
1025        assert!(rt::allclose(&b, &expected, None));
1026        assert_eq!(b.stride(), &[4, 2, 1]);
1027        let b = rt::asarray((&a, TensorIterOrder::F));
1028        println!("{b:2?}");
1029        // shape: [2, 2, 2], stride: [1, 2, 4], offset: 0
1030        assert!(rt::allclose(&b, &expected, None));
1031        assert_eq!(b.stride(), &[1, 2, 4]);
1032    }
1033}
rstsr_core/tensor/asarray.rs

rstsr_core/tensor/
asarray.rs
