rstsr-common 0.7.3

An n-Dimension Rust Tensor Toolkit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Cast `Vec<T>` to/from `Vec<[T; N]>` (or its reference) without copying.

use crate::prelude_dev::*;
use core::mem::ManuallyDrop;

pub trait PackableArrayAPI<T, const N: usize> {
    type Array;
    type ArrayVec;
}

pub trait PackArrayAPI<T> {
    fn pack_array_f<const N: usize>(self) -> Result<Self::ArrayVec>
    where
        Self: PackableArrayAPI<T, N>;
    fn pack_array<const N: usize>(self) -> Self::ArrayVec
    where
        Self: PackableArrayAPI<T, N> + Sized,
    {
        self.pack_array_f().unwrap()
    }
}

pub trait UnpackArrayAPI {
    type Output;
    fn unpack_array(self) -> Self::Output;
}

/* #region impl of Vec<T> */

impl<T, const N: usize> PackableArrayAPI<T, N> for Vec<T> {
    type Array = [T; N];
    type ArrayVec = Vec<[T; N]>;
}

impl<T> PackArrayAPI<T> for Vec<T> {
    fn pack_array_f<const N: usize>(self) -> Result<<Self as PackableArrayAPI<T, N>>::ArrayVec> {
        let len = self.len();
        rstsr_assert!(
            len % N == 0,
            InvalidValue,
            "Length of Vec<T> {len} must be a multiple to cast into Vec<[T; {N}]>"
        )?;
        let vec = ManuallyDrop::new(self);
        let arr = unsafe { Vec::from_raw_parts(vec.as_ptr() as *mut [T; N], len / N, len / N) };
        Ok(arr)
    }
}

impl<T, const N: usize> UnpackArrayAPI for Vec<[T; N]> {
    type Output = Vec<T>;

    fn unpack_array(self) -> Self::Output {
        let len = self.len();
        let arr = ManuallyDrop::new(self);
        unsafe { Vec::from_raw_parts(arr.as_ptr() as *mut T, len * N, len * N) }
    }
}

/* #endregion */

/* #region impl of &[T] */

impl<'l, T, const N: usize> PackableArrayAPI<T, N> for &'l [T] {
    type Array = [T; N];
    type ArrayVec = &'l [[T; N]];
}

impl<T> PackArrayAPI<T> for &[T] {
    fn pack_array_f<const N: usize>(self) -> Result<<Self as PackableArrayAPI<T, N>>::ArrayVec> {
        let len = self.len();
        rstsr_assert!(
            len % N == 0,
            InvalidValue,
            "Length of &[T] {len} must be a multiple to cast into Vec<[T; {N}]>"
        )?;
        let arr = unsafe { core::slice::from_raw_parts(self.as_ptr() as *const [T; N], len / N) };
        Ok(arr)
    }
}

impl<'l, T, const N: usize> UnpackArrayAPI for &'l [[T; N]] {
    type Output = &'l [T];

    fn unpack_array(self) -> Self::Output {
        let len = self.len();
        unsafe { core::slice::from_raw_parts(self.as_ptr() as *const T, len * N) }
    }
}

/* #endregion */

/* #region impl of &mut [T] */

impl<'l, T, const N: usize> PackableArrayAPI<T, N> for &'l mut [T] {
    type Array = [T; N];
    type ArrayVec = &'l mut [[T; N]];
}

impl<T> PackArrayAPI<T> for &mut [T] {
    fn pack_array_f<const N: usize>(self) -> Result<<Self as PackableArrayAPI<T, N>>::ArrayVec> {
        let len = self.len();
        rstsr_assert!(
            len % N == 0,
            InvalidValue,
            "Length of &[T] {len} must be a multiple to cast into Vec<[T; {N}]>"
        )?;
        let arr = unsafe { core::slice::from_raw_parts_mut(self.as_mut_ptr() as *mut [T; N], len / N) };
        Ok(arr)
    }
}

impl<'l, T, const N: usize> UnpackArrayAPI for &'l mut [[T; N]] {
    type Output = &'l mut [T];

    fn unpack_array(self) -> Self::Output {
        let len = self.len();
        unsafe { core::slice::from_raw_parts_mut(self.as_ptr() as *mut T, len * N) }
    }
}

/* #endregion */

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn playground() {
        let v1 = vec![1, 2, 3, 4, 5, 6];
        let ptr_v1 = v1.as_ptr();

        let a1: Vec<[i32; 2]> = v1.pack_array();
        let ptr_a1 = a1.as_ptr();
        assert_eq!(a1, vec![[1, 2], [3, 4], [5, 6]]);
        assert_eq!(ptr_v1, ptr_a1 as *const i32);

        let v2: Vec<i32> = a1.unpack_array();
        let ptr_v2 = v2.as_ptr();
        assert_eq!(v2, vec![1, 2, 3, 4, 5, 6]);
        assert_eq!(ptr_v1, ptr_v2);
    }
}