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

//! Implementation of array addition

use std::ops::Sub;

use crate::{
    ContainerType, ContainerTypeSelector, SelectContainerType,
    dense::array::Array,
    traits::{
        accessors::{UnsafeRandom1DAccessByValue, UnsafeRandomAccessByValue},
        base_operations::{BaseItem, Shape},
    },
};

/// Subtraction
pub struct ArraySubtraction<ArrayImpl1, ArrayImpl2, const NDIM: usize> {
    operator1: Array<ArrayImpl1, NDIM>,
    operator2: Array<ArrayImpl2, NDIM>,
}

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> ArraySubtraction<ArrayImpl1, ArrayImpl2, NDIM>
where
    ArrayImpl1: Shape<NDIM>,
    ArrayImpl2: Shape<NDIM>,
{
    /// Create new
    pub fn new(operator1: Array<ArrayImpl1, NDIM>, operator2: Array<ArrayImpl2, NDIM>) -> Self {
        assert_eq!(
            operator1.shape(),
            operator2.shape(),
            "In op1 - op2 shapes not identical. op1.shape = {:#?}, op2.shape = {:#?}",
            operator1.shape(),
            operator2.shape()
        );
        Self {
            operator1,
            operator2,
        }
    }
}

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> ContainerType
    for ArraySubtraction<ArrayImpl1, ArrayImpl2, NDIM>
where
    ArrayImpl1: ContainerType,
    ArrayImpl2: ContainerType,
    SelectContainerType: ContainerTypeSelector<ArrayImpl1::Type, ArrayImpl2::Type>,
{
    type Type =
        <SelectContainerType as ContainerTypeSelector<ArrayImpl1::Type, ArrayImpl2::Type>>::Type;
}

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

impl<Item: Copy + Default, ArrayImpl1, ArrayImpl2, const NDIM: usize>
    UnsafeRandomAccessByValue<NDIM> for ArraySubtraction<ArrayImpl1, ArrayImpl2, NDIM>
where
    ArrayImpl1: UnsafeRandomAccessByValue<NDIM> + BaseItem<Item = Item>,
    ArrayImpl2: UnsafeRandomAccessByValue<NDIM> + BaseItem<Item = Item>,
    ArrayImpl1::Item: Sub<ArrayImpl2::Item, Output = Item>,
{
    #[inline(always)]
    unsafe fn get_value_unchecked(&self, multi_index: [usize; NDIM]) -> Self::Item {
        unsafe {
            self.operator1.get_value_unchecked(multi_index)
                - self.operator2.get_value_unchecked(multi_index)
        }
    }
}

impl<Item, ArrayImpl1, ArrayImpl2, const NDIM: usize> UnsafeRandom1DAccessByValue
    for ArraySubtraction<ArrayImpl1, ArrayImpl2, NDIM>
where
    ArrayImpl1: UnsafeRandom1DAccessByValue + BaseItem<Item = Item>,
    ArrayImpl2: UnsafeRandom1DAccessByValue + BaseItem<Item = Item>,
    ArrayImpl1::Item: Sub<ArrayImpl2::Item, Output = Item>,
    Item: Copy + Default,
{
    #[inline(always)]
    unsafe fn get_value_1d_unchecked(&self, index: usize) -> Self::Item {
        unsafe {
            self.operator1.imp().get_value_1d_unchecked(index)
                - self.operator2.imp().get_value_1d_unchecked(index)
        }
    }
}

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> Shape<NDIM>
    for ArraySubtraction<ArrayImpl1, ArrayImpl2, NDIM>
where
    ArrayImpl1: Shape<NDIM>,
{
    #[inline(always)]
    fn shape(&self) -> [usize; NDIM] {
        self.operator1.shape()
    }
}