tensor_optim 0.3.0

A tiny tensor engine lacking compromise on portability
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

pub mod array;
pub mod views;

#[cfg(feature = "alloc")]
pub mod dynamic;

/// Operations even the simplest tensors need to get indexing, shape, and other content.
pub trait TensorOps<T> {
    /// Provides the shape of the current tensor as a slice.
    ///
    /// Note: the builtin `index_offset` method will work immediately if the shape is stored row-major.
    fn shape(&self) -> &[usize];

    /// Provides the data of the current tensor in a slice of a generic `T`.
    ///
    /// Note: the builtin `index_offset` method will work immediately if the data is stored row-major.
    fn data(&self) -> &[T];

    /// Provides the data of the current tensor in a slice of a generic `T`.
    ///
    /// Note: the builtin `index_offset` method will work immediately if the data is stored row-major.
    fn data_mut(&mut self) -> &mut [T];

    /// Finds the index in `data` given a slice with one entry/dimension.
    fn index_offset(&self, idx: &[usize]) -> Option<usize> {
        if idx.len() != self.shape().len() {
            return None;
        }
        let mut stride = 1;
        let mut flat_index = 0;
        for (&i, &dim) in idx.iter().rev().zip(self.shape().iter().rev()) {
            if i >= dim {
                return None; // out of bounds
            }
            flat_index += i * stride;
            stride *= dim;
        }
        Some(flat_index)
    }
}

/// Operations only statically sized, non-allocating tensors can leverage.
pub trait ConstTensorOps<T, const N: usize, const D: usize>: TensorOps<T> {
    /// Provides the shape of the current tensor as an array.
    ///
    /// Note: the builtin `index_offset` method will work immediately if the shape is stored row-major.
    fn shape_array(&self) -> &[usize; D];

    /// Provides the data of the current tensor in a slice of a generic `T`.
    ///
    /// Note: the builtin `index_offset` method will work immediately if the data is stored row-major.
    fn data_array(&self) -> &[T; N];

    /// Provides the data of the current tensor in a slice of a generic `T`.
    ///
    /// Note: the builtin `index_offset` method will work immediately if the data is stored row-major.
    fn data_mut_array(&mut self) -> &mut [T; N];
}

/// A small limit to ranks.
///
/// Primarily for matrix multiplication in `ArrTensor`.
pub const MAX_STATIC_RANK: usize = 12;