simdeez 3.0.1

SIMD library to abstract over different instruction sets and widths
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

use crate::SimdConsts;

pub trait SimdBaseIo: SimdConsts {
    /// Transmutes the vector into a array representation defined by `Self::ArrayRepresentation`.
    /// Please don't use this function directly unless necessary.
    #[inline(always)]
    unsafe fn transmute_into_array_ref(&self) -> &Self::ArrayRepresentation {
        core::mem::transmute(self)
    }

    /// Transmutes the vector into a mutable array representation defined by `Self::ArrayRepresentation`.
    /// Please don't use this function directly unless necessary.
    #[inline(always)]
    unsafe fn transmute_into_array_mut(&mut self) -> &mut Self::ArrayRepresentation {
        core::mem::transmute(self)
    }

    /// Initialize a vector with all elements set to zero
    fn zeroes() -> Self;

    /// Initialize a vector with all elements set to the same value
    fn set1(x: Self::Scalar) -> Self;

    unsafe fn load_from_array(array: Self::ArrayRepresentation) -> Self;
    unsafe fn as_array(&self) -> Self::ArrayRepresentation {
        self.transmute_into_array_ref().clone()
    }

    /// Load a vector from an unaligned raw pointer.
    unsafe fn load_from_ptr_unaligned(ptr: *const Self::Scalar) -> Self;
    /// Store a vector to an unaligned raw pointer.
    unsafe fn copy_to_ptr_unaligned(self, ptr: *mut Self::Scalar);

    /// Load a vector from a 32 bit aligned raw pointer.
    unsafe fn load_from_ptr_aligned(ptr: *const Self::Scalar) -> Self;
    /// Store a vector to a 32 bit aligned raw pointer.
    unsafe fn copy_to_ptr_aligned(self, ptr: *mut Self::Scalar);

    unsafe fn underlying_value(self) -> Self::UnderlyingType;
    unsafe fn underlying_value_mut(&mut self) -> &mut Self::UnderlyingType;
    unsafe fn from_underlying_value(value: Self::UnderlyingType) -> Self;

    /// Gets the value at the specified index, without a bounds check.
    #[inline(always)]
    unsafe fn get_unchecked(&self, index: usize) -> Self::Scalar {
        unsafe {
            let underlying_ptr = &self.underlying_value() as *const Self::UnderlyingType;
            let ptr_scalar = underlying_ptr as *mut Self::Scalar;
            let ptr = ptr_scalar.add(index);
            *ptr
        }
    }

    /// Gets the value at the specified index, without a bounds check.
    #[inline(always)]
    unsafe fn get_unchecked_mut<'a>(&mut self, index: usize) -> &'a mut Self::Scalar {
        unsafe {
            let underlying_ptr = self.underlying_value_mut() as *mut Self::UnderlyingType;
            let ptr_scalar = underlying_ptr as *mut Self::Scalar;
            let ptr = ptr_scalar.add(index);
            &mut *ptr
        }
    }

    /// Tries to load from a slice. If the slice is too short, it returns the length of the slice.
    fn load_from_slice_exact(slice: &[Self::Scalar]) -> Result<Self, usize> {
        if slice.len() < Self::WIDTH {
            Err(slice.len())
        } else {
            unsafe { Ok(Self::load_from_ptr_unaligned(slice.as_ptr())) }
        }
    }

    /// Tries to load from a slice. If the slice is too short, it uses zeroes for the remaining values.
    fn load_from_slice(slice: &[Self::Scalar]) -> Self {
        unsafe {
            if slice.len() < Self::WIDTH {
                let mut val = Self::zeroes();
                for (i, s) in slice.iter().copied().enumerate() {
                    let ptr = val.get_unchecked_mut(i);
                    *ptr = s;
                }
                val
            } else {
                Self::load_from_ptr_unaligned(slice.as_ptr())
            }
        }
    }

    /// Tries to copy to a slice. If the slice is too short, it returns the length of the slice.
    fn copy_to_slice_exact(self, slice: &mut [Self::Scalar]) -> Result<(), usize> {
        unsafe {
            if slice.len() < Self::WIDTH {
                Err(slice.len())
            } else {
                self.copy_to_ptr_unaligned(slice.as_mut_ptr());
                Ok(())
            }
        }
    }

    /// Tries to copy to a slice. If the slice is too short, it copies as much as possible until the end of the slice.
    fn copy_to_slice(self, slice: &mut [Self::Scalar]) {
        unsafe {
            if slice.len() < Self::WIDTH {
                for (i, s) in slice.iter_mut().enumerate() {
                    *s = self.get_unchecked(i);
                }
            } else {
                self.copy_to_ptr_unaligned(slice.as_mut_ptr());
            }
        }
    }
}