rlst 0.10.0

A Rust native linear algebra library.
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
143
144
145
146
147
148
149
150

//! Reverse a single axis of an array.

use crate::ContainerType;
use crate::dense::array::Array;
use crate::dense::layout::convert_1d_nd_from_shape;
use crate::traits::accessors::{
    UnsafeRandom1DAccessByRef, UnsafeRandom1DAccessByValue, UnsafeRandom1DAccessMut,
    UnsafeRandomAccessByRef, UnsafeRandomAccessByValue, UnsafeRandomAccessMut,
};
use crate::traits::base_operations::{BaseItem, Shape};

/// This struct represents an array implementation with a single axis reversed.
pub struct ReverseAxis<ArrayImpl, const NDIM: usize> {
    arr: Array<ArrayImpl, NDIM>,
    axis: usize,
}

impl<ArrayImpl, const NDIM: usize> ReverseAxis<ArrayImpl, NDIM> {
    /// Create a lazy view that reverses `axis`.
    ///
    /// `axis` must be less than `NDIM`; prefer [`Array::reverse_axis`], which checks this
    /// requirement immediately.
    pub fn new(arr: Array<ArrayImpl, NDIM>, axis: usize) -> Self {
        Self { arr, axis }
    }
}

impl<ArrayImpl, const NDIM: usize> Shape<NDIM> for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: Shape<NDIM>,
{
    #[inline(always)]
    fn shape(&self) -> [usize; NDIM] {
        self.arr.shape()
    }
}

impl<ArrayImpl, const NDIM: usize> ContainerType for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: ContainerType,
{
    type Type = ArrayImpl::Type;
}

impl<Item, ArrayImpl, const NDIM: usize> BaseItem for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: BaseItem<Item = Item>,
    Item: Copy + Default,
{
    type Item = Item;
}

impl<ArrayImpl, const NDIM: usize> UnsafeRandomAccessByValue<NDIM> for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: UnsafeRandomAccessByValue<NDIM> + Shape<NDIM>,
{
    #[inline(always)]
    unsafe fn get_value_unchecked(&self, multi_index: [usize; NDIM]) -> Self::Item {
        unsafe {
            self.arr.get_value_unchecked(reverse_multi_index(
                multi_index,
                self.axis,
                self.arr.shape(),
            ))
        }
    }
}

impl<ArrayImpl, const NDIM: usize> UnsafeRandomAccessByRef<NDIM> for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: UnsafeRandomAccessByRef<NDIM> + Shape<NDIM>,
{
    #[inline(always)]
    unsafe fn get_unchecked(&self, multi_index: [usize; NDIM]) -> &Self::Item {
        unsafe {
            self.arr.get_unchecked(reverse_multi_index(
                multi_index,
                self.axis,
                self.arr.shape(),
            ))
        }
    }
}

impl<ArrayImpl, const NDIM: usize> UnsafeRandomAccessMut<NDIM> for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: UnsafeRandomAccessMut<NDIM> + Shape<NDIM>,
{
    #[inline(always)]
    unsafe fn get_unchecked_mut(&mut self, multi_index: [usize; NDIM]) -> &mut Self::Item {
        unsafe {
            self.arr.get_unchecked_mut(reverse_multi_index(
                multi_index,
                self.axis,
                self.arr.shape(),
            ))
        }
    }
}

impl<ArrayImpl, const NDIM: usize> UnsafeRandom1DAccessByValue for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: UnsafeRandomAccessByValue<NDIM> + Shape<NDIM>,
{
    #[inline(always)]
    unsafe fn get_value_1d_unchecked(&self, index: usize) -> Self::Item {
        let multi_index = convert_1d_nd_from_shape(index, self.arr.shape());
        unsafe { self.get_value_unchecked(multi_index) }
    }
}

impl<ArrayImpl, const NDIM: usize> UnsafeRandom1DAccessByRef for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: UnsafeRandomAccessByRef<NDIM> + Shape<NDIM>,
{
    #[inline(always)]
    unsafe fn get_1d_unchecked(&self, index: usize) -> &Self::Item {
        let multi_index = convert_1d_nd_from_shape(index, self.arr.shape());
        unsafe { self.get_unchecked(multi_index) }
    }
}

impl<ArrayImpl, const NDIM: usize> UnsafeRandom1DAccessMut for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: UnsafeRandomAccessMut<NDIM> + Shape<NDIM>,
{
    #[inline(always)]
    unsafe fn get_1d_unchecked_mut(&mut self, index: usize) -> &mut Self::Item {
        let multi_index = convert_1d_nd_from_shape(index, self.arr.shape());
        unsafe { self.get_unchecked_mut(multi_index) }
    }
}

#[inline(always)]
fn reverse_multi_index<const NDIM: usize>(
    mut multi_index: [usize; NDIM],
    axis: usize,
    shape: [usize; NDIM],
) -> [usize; NDIM] {
    multi_index[axis] = shape[axis] - 1 - multi_index[axis];
    multi_index
}

// SAFETY: reversing an axis is an injective permutation of source indices.
unsafe impl<ArrayImpl, const NDIM: usize> crate::UnsafeDisjointRandom1DAccessMut
    for ReverseAxis<ArrayImpl, NDIM>
where
    ArrayImpl: crate::UnsafeDisjointRandom1DAccessMut + UnsafeRandomAccessMut<NDIM> + Shape<NDIM>,
{
}