Struct easy_ml::tensors::views::TensorIndex

pub struct TensorIndex<T, S, const D: usize, const I: usize> { /* private fields */ }

A combination of pre provided indexes and a tensor. The provided indexes reduce the dimensionality of the TensorRef exposed to less than the dimensionality of the TensorRef this is created from.

use easy_ml::tensors::Tensor;
use easy_ml::tensors::views::{TensorView, TensorIndex};
let vector = Tensor::from([("a", 2)], vec![ 16, 8 ]);
let scalar = vector.select([("a", 0)]);
let also_scalar = TensorView::from(TensorIndex::from(&vector, [("a", 0)]));
assert_eq!(scalar.index_by([]).get([]), also_scalar.index_by([]).get([]));
assert_eq!(scalar.index_by([]).get([]), 16);

Note: due to limitations in Rust’s const generics support, TensorIndex only implements TensorRef for D from 1 to 6.

Implementations

impl<T, S, const D: usize, const I: usize> TensorIndex<T, S, D, I>

where S: TensorRef<T, D>,

pub fn from( source: S, provided_indexes: [(Dimension, usize); I], ) -> TensorIndex<T, S, D, I>

Creates a TensorIndex from a source and a list of provided dimension name/index pairs.

The corresponding dimensions in the source will be masked to always return the provided index. Henece, a matrix can be viewed as a vector if you provide one of the row/column index to use. More generally, the tensor the TensorIndex exposes will have a dimensionality of D - I, where D is the dimensionality of the source, and I is the dimensionality of the provided indexes.

Panics

• If any provided index is for a dimension that does not exist in the source’s shape.
• If any provided index is not within range for the length of the dimension.
• If multiple indexes are provided for the same dimension.

pub fn source(self) -> S

pub fn source_ref(&self) -> &S

Trait Implementations

impl<T: Clone, S: Clone, const D: usize, const I: usize> Clone for TensorIndex<T, S, D, I>

fn clone(&self) -> TensorIndex<T, S, D, I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, S: Debug, const D: usize, const I: usize> Debug for TensorIndex<T, S, D, I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 1, 1>

where S: TensorMut<T, 1>,

fn get_reference_mut(&mut self, indexes: [usize; 0]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 0]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 2, 1>

where S: TensorMut<T, 2>,

fn get_reference_mut(&mut self, indexes: [usize; 1]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 1]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 2, 2>

where S: TensorMut<T, 2>,

fn get_reference_mut(&mut self, indexes: [usize; 0]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 0]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 3, 1>

where S: TensorMut<T, 3>,

fn get_reference_mut(&mut self, indexes: [usize; 2]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 2]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 3, 2>

where S: TensorMut<T, 3>,

fn get_reference_mut(&mut self, indexes: [usize; 1]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 1]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 3, 3>

where S: TensorMut<T, 3>,

fn get_reference_mut(&mut self, indexes: [usize; 0]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 0]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 4, 1>

where S: TensorMut<T, 4>,

fn get_reference_mut(&mut self, indexes: [usize; 3]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 3]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 4, 2>

where S: TensorMut<T, 4>,

fn get_reference_mut(&mut self, indexes: [usize; 2]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 2]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 4, 3>

where S: TensorMut<T, 4>,

fn get_reference_mut(&mut self, indexes: [usize; 1]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 1]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 4, 4>

where S: TensorMut<T, 4>,

fn get_reference_mut(&mut self, indexes: [usize; 0]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 0]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 5, 1>

where S: TensorMut<T, 5>,

fn get_reference_mut(&mut self, indexes: [usize; 4]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 4]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 5, 2>

where S: TensorMut<T, 5>,

fn get_reference_mut(&mut self, indexes: [usize; 3]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 3]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 5, 3>

where S: TensorMut<T, 5>,

fn get_reference_mut(&mut self, indexes: [usize; 2]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 2]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 5, 4>

where S: TensorMut<T, 5>,

fn get_reference_mut(&mut self, indexes: [usize; 1]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 1]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 5, 5>

where S: TensorMut<T, 5>,

fn get_reference_mut(&mut self, indexes: [usize; 0]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 0]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 6, 1>

where S: TensorMut<T, 6>,

fn get_reference_mut(&mut self, indexes: [usize; 5]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 5]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 6, 2>

where S: TensorMut<T, 6>,

fn get_reference_mut(&mut self, indexes: [usize; 4]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 4]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 6, 3>

where S: TensorMut<T, 6>,

fn get_reference_mut(&mut self, indexes: [usize; 3]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 3]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 6, 4>

where S: TensorMut<T, 6>,

fn get_reference_mut(&mut self, indexes: [usize; 2]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 2]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 6, 5>

where S: TensorMut<T, 6>,

fn get_reference_mut(&mut self, indexes: [usize; 1]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 1]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorMut<T, { $d - $i }> for TensorIndex<T, S, 6, 6>

where S: TensorMut<T, 6>,

fn get_reference_mut(&mut self, indexes: [usize; 0]) -> Option<&mut T>

Gets a mutable reference to the value at the index, if the index is in range. Otherwise returns None.

unsafe fn get_reference_unchecked_mut(&mut self, indexes: [usize; 0]) -> &mut T

Gets a mutable reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference_mut.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 1, 1>

where S: TensorRef<T, 1>,

fn get_reference(&self, indexes: [usize; 0]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 0]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 0]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 2, 1>

where S: TensorRef<T, 2>,

fn get_reference(&self, indexes: [usize; 1]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 1]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 1]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 2, 2>

where S: TensorRef<T, 2>,

fn get_reference(&self, indexes: [usize; 0]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 0]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 0]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 3, 1>

where S: TensorRef<T, 3>,

fn get_reference(&self, indexes: [usize; 2]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 2]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 2]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 3, 2>

where S: TensorRef<T, 3>,

fn get_reference(&self, indexes: [usize; 1]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 1]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 1]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 3, 3>

where S: TensorRef<T, 3>,

fn get_reference(&self, indexes: [usize; 0]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 0]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 0]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 4, 1>

where S: TensorRef<T, 4>,

fn get_reference(&self, indexes: [usize; 3]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 3]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 3]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 4, 2>

where S: TensorRef<T, 4>,

fn get_reference(&self, indexes: [usize; 2]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 2]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 2]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 4, 3>

where S: TensorRef<T, 4>,

fn get_reference(&self, indexes: [usize; 1]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 1]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 1]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 4, 4>

where S: TensorRef<T, 4>,

fn get_reference(&self, indexes: [usize; 0]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 0]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 0]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 5, 1>

where S: TensorRef<T, 5>,

fn get_reference(&self, indexes: [usize; 4]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 4]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 4]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 5, 2>

where S: TensorRef<T, 5>,

fn get_reference(&self, indexes: [usize; 3]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 3]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 3]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 5, 3>

where S: TensorRef<T, 5>,

fn get_reference(&self, indexes: [usize; 2]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 2]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 2]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 5, 4>

where S: TensorRef<T, 5>,

fn get_reference(&self, indexes: [usize; 1]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 1]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 1]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 5, 5>

where S: TensorRef<T, 5>,

fn get_reference(&self, indexes: [usize; 0]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 0]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 0]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 6, 1>

where S: TensorRef<T, 6>,

fn get_reference(&self, indexes: [usize; 5]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 5]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 5]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 6, 2>

where S: TensorRef<T, 6>,

fn get_reference(&self, indexes: [usize; 4]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 4]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 4]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 6, 3>

where S: TensorRef<T, 6>,

fn get_reference(&self, indexes: [usize; 3]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 3]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 3]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 6, 4>

where S: TensorRef<T, 6>,

fn get_reference(&self, indexes: [usize; 2]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 2]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 2]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 6, 5>

where S: TensorRef<T, 6>,

fn get_reference(&self, indexes: [usize; 1]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 1]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 1]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.

impl<T, S> TensorRef<T, { $d - $i }> for TensorIndex<T, S, 6, 6>

where S: TensorRef<T, 6>,

fn get_reference(&self, indexes: [usize; 0]) -> Option<&T>

Gets a reference to the value at the index if the index is in range. Otherwise returns None.

fn view_shape(&self) -> [(Dimension, usize); 0]

The shape this tensor has. See dimensions for an overview. The product of the lengths in the pairs define how many elements are in the tensor (or the portion of it that is visible).

unsafe fn get_reference_unchecked(&self, indexes: [usize; 0]) -> &T

Gets a reference to the value at the index without doing any bounds checking. For a safe alternative see get_reference.

fn data_layout(&self) -> DataLayout<{ _ }>

The way the data in this tensor is laid out in memory. In particular, Linear has several requirements on what is returned that must be upheld by implementations of this trait.