linfa-linalg 0.2.1

Pure-Rust implementation of linear algebra routines for ndarray
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

//! This module provides indexing methods that do checked access in debug mode and unchecked
//! accesses in release mode. Technically these methods are all unsafe. However, they're all
//! internal APIs, so all callers are guaranteed to be well-tested to prevent out-of-bounds
//! accesses.

use ndarray::{ArrayBase, Data, DataMut, Dimension, NdIndex};

pub(crate) trait UncheckedIndex<I> {
    type Elem;
    unsafe fn at(&self, index: I) -> &Self::Elem;
}

pub(crate) trait UncheckedIndexMut<I> {
    type Elem;
    unsafe fn atm(&mut self, index: I) -> &mut Self::Elem;
}

impl<A, S: Data<Elem = A>, D: Dimension, I: NdIndex<D>> UncheckedIndex<I> for ArrayBase<S, D> {
    type Elem = A;

    unsafe fn at(&self, index: I) -> &Self::Elem {
        #[cfg(debug_assertions)]
        {
            self.get(index).unwrap()
        }
        #[cfg(not(debug_assertions))]
        self.uget(index)
    }
}

impl<A, S: DataMut<Elem = A>, D: Dimension, I: NdIndex<D>> UncheckedIndexMut<I>
    for ArrayBase<S, D>
{
    type Elem = A;

    unsafe fn atm(&mut self, index: I) -> &mut Self::Elem {
        #[cfg(debug_assertions)]
        {
            self.get_mut(index).unwrap()
        }
        #[cfg(not(debug_assertions))]
        self.uget_mut(index)
    }
}