Trait tract_core::internal::tract_ndarray::Dimension

pub trait Dimension: Clone + Eq + Debug + Send + Sync + Default + IndexMut<usize, Output = usize> + Add<Self, Output = Self> + AddAssign<Self> + for<'x> AddAssign<&'x Self> + Sub<Self, Output = Self> + SubAssign<Self> + for<'x> SubAssign<&'x Self> + Mul<usize, Output = Self, Output = Self> + Mul<Self> + MulAssign<Self> + for<'x> MulAssign<&'x Self> + MulAssign<usize> + DimMax<Dim<[usize; 0]>, Output = Self, Output = Self, Output = Dim<IxDynImpl>, Output = Self, Output = Self::Larger> + DimMax<Self> + DimMax<Dim<IxDynImpl>> + DimMax<Self::Smaller> + DimMax<Self::Larger> + DimAdd<Self, Output = Self, Output = Self::Larger, Output = Dim<IxDynImpl>> + DimAdd<Self::Smaller> + DimAdd<Self::Larger> + DimAdd<Dim<[usize; 0]>> + DimAdd<Dim<[usize; 1]>> + DimAdd<Dim<IxDynImpl>> {
    type Pattern: IntoDimension + Clone + Debug + PartialEq<Self::Pattern> + Eq + Default;
    type Smaller: Dimension;
    type Larger: Dimension + RemoveAxis;

    const NDIM: Option<usize>;

    fn ndim(&self) -> usize;
    fn into_pattern(self) -> Self::Pattern;
    fn zeros(ndim: usize) -> Self;
    fn __private__(&self) -> PrivateMarker;

    fn size(&self) -> usize { ... }
    fn size_checked(&self) -> Option<usize> { ... }
    fn as_array_view(&self) -> ArrayBase<ViewRepr<&usize>, Dim<[usize; 1]>> { ... }
    fn as_array_view_mut(
        &mut self
    ) -> ArrayBase<ViewRepr<&mut usize>, Dim<[usize; 1]>> { ... }
    fn into_dyn(self) -> Dim<IxDynImpl> { ... }
}

Array shape and index trait.

This trait defines a number of methods and operations that can be used on dimensions and indices.

Note: This trait can not be implemented outside the crate

Associated Types

type Pattern: IntoDimension + Clone + Debug + PartialEq<Self::Pattern> + Eq + Default

Pattern matching friendly form of the dimension value.

• For Ix1: usize,
• For Ix2: (usize, usize)
• and so on..
• For IxDyn: IxDyn

type Smaller: Dimension

Next smaller dimension (if applicable)

type Larger: Dimension + RemoveAxis

Next larger dimension

Associated Constants

const NDIM: Option<usize>

For fixed-size dimension representations (e.g. Ix2), this should be Some(ndim), and for variable-size dimension representations (e.g. IxDyn), this should be None.

Required methods

fn ndim(&self) -> usize

Returns the number of dimensions (number of axes).

fn into_pattern(self) -> Self::Pattern

Convert the dimension into a pattern matching friendly value.

fn zeros(ndim: usize) -> Self

Creates a dimension of all zeros with the specified ndim.

This method is useful for generalizing over fixed-size and variable-size dimension representations.

Panics if Self has a fixed size that is not ndim.

fn __private__(&self) -> PrivateMarker

This trait is private to implement; this method exists to make it impossible to implement outside the crate.

Provided methods

fn size(&self) -> usize

Compute the size of the dimension (number of elements)

fn size_checked(&self) -> Option<usize>

Compute the size while checking for overflow.

fn as_array_view(&self) -> ArrayBase<ViewRepr<&usize>, Dim<[usize; 1]>>

Borrow as a read-only array view.

fn as_array_view_mut(
    &mut self
) -> ArrayBase<ViewRepr<&mut usize>, Dim<[usize; 1]>>

Borrow as a read-write array view.

fn into_dyn(self) -> Dim<IxDynImpl>

Convert the dimensional into a dynamic dimensional (IxDyn).

Implementors

impl Dimension for Dim<[usize; 0]>

pub const NDIM: Option<usize>

type Pattern = ()

type Smaller = Dim<[usize; 0]>

type Larger = Dim<[usize; 1]>

pub fn ndim(&self) -> usize

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn _fastest_varying_stride_order(&self) -> Dim<[usize; 0]>

pub fn into_pattern(self) -> <Dim<[usize; 0]> as Dimension>::Pattern

pub fn zeros(ndim: usize) -> Dim<[usize; 0]>

pub fn next_for(&self, _index: Dim<[usize; 0]>) -> Option<Dim<[usize; 0]>>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 0]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    _ignore: Axis
) -> <Dim<[usize; 0]> as Dimension>::Smaller

impl Dimension for Dim<[usize; 1]>

pub const NDIM: Option<usize>

type Pattern = usize

type Smaller = Dim<[usize; 0]>

type Larger = Dim<[usize; 2]>

pub fn ndim(&self) -> usize

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn into_pattern(self) -> <Dim<[usize; 1]> as Dimension>::Pattern

pub fn zeros(ndim: usize) -> Dim<[usize; 1]>

pub fn next_for(&self, index: Dim<[usize; 1]>) -> Option<Dim<[usize; 1]>>

pub fn equal(&self, rhs: &Dim<[usize; 1]>) -> bool

pub fn size(&self) -> usize

pub fn size_checked(&self) -> Option<usize>

pub fn default_strides(&self) -> Dim<[usize; 1]>

pub fn _fastest_varying_stride_order(&self) -> Dim<[usize; 1]>

pub fn min_stride_axis(&self, &Dim<[usize; 1]>) -> Axis

pub fn max_stride_axis(&self, &Dim<[usize; 1]>) -> Axis

pub fn first_index(&self) -> Option<Dim<[usize; 1]>>

pub fn stride_offset(index: &Dim<[usize; 1]>, stride: &Dim<[usize; 1]>) -> isize

pub fn stride_offset_checked(
    &self,
    stride: &Dim<[usize; 1]>,
    index: &Dim<[usize; 1]>
) -> Option<isize>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 1]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<[usize; 1]> as Dimension>::Smaller

pub fn from_dimension<D2>(d: &D2) -> Option<Dim<[usize; 1]>> where
    D2: Dimension, 

impl Dimension for Dim<[usize; 2]>

pub const NDIM: Option<usize>

type Pattern = (usize, usize)

type Smaller = Dim<[usize; 1]>

type Larger = Dim<[usize; 3]>

pub fn ndim(&self) -> usize

pub fn into_pattern(self) -> <Dim<[usize; 2]> as Dimension>::Pattern

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn zeros(ndim: usize) -> Dim<[usize; 2]>

pub fn next_for(&self, index: Dim<[usize; 2]>) -> Option<Dim<[usize; 2]>>

pub fn equal(&self, rhs: &Dim<[usize; 2]>) -> bool

pub fn size(&self) -> usize

pub fn size_checked(&self) -> Option<usize>

pub fn last_elem(&self) -> usize

pub fn set_last_elem(&mut self, i: usize)

pub fn default_strides(&self) -> Dim<[usize; 2]>

pub fn fortran_strides(&self) -> Dim<[usize; 2]>

pub fn _fastest_varying_stride_order(&self) -> Dim<[usize; 2]>

pub fn min_stride_axis(&self, strides: &Dim<[usize; 2]>) -> Axis

pub fn first_index(&self) -> Option<Dim<[usize; 2]>>

pub fn stride_offset(
    index: &Dim<[usize; 2]>,
    strides: &Dim<[usize; 2]>
) -> isize

pub fn stride_offset_checked(
    &self,
    strides: &Dim<[usize; 2]>,
    index: &Dim<[usize; 2]>
) -> Option<isize>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 2]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<[usize; 2]> as Dimension>::Smaller

impl Dimension for Dim<[usize; 3]>

pub const NDIM: Option<usize>

type Pattern = (usize, usize, usize)

type Smaller = Dim<[usize; 2]>

type Larger = Dim<[usize; 4]>

pub fn ndim(&self) -> usize

pub fn into_pattern(self) -> <Dim<[usize; 3]> as Dimension>::Pattern

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn size(&self) -> usize

pub fn zeros(ndim: usize) -> Dim<[usize; 3]>

pub fn next_for(&self, index: Dim<[usize; 3]>) -> Option<Dim<[usize; 3]>>

pub fn stride_offset(
    index: &Dim<[usize; 3]>,
    strides: &Dim<[usize; 3]>
) -> isize

pub fn stride_offset_checked(
    &self,
    strides: &Dim<[usize; 3]>,
    index: &Dim<[usize; 3]>
) -> Option<isize>

pub fn _fastest_varying_stride_order(&self) -> Dim<[usize; 3]>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 3]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<[usize; 3]> as Dimension>::Smaller

impl Dimension for Dim<[usize; 4]>

pub const NDIM: Option<usize>

type Pattern = (usize, usize, usize, usize)

type Smaller = Dim<[usize; 3]>

type Larger = Dim<[usize; 5]>

pub fn ndim(&self) -> usize

pub fn into_pattern(self) -> <Dim<[usize; 4]> as Dimension>::Pattern

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn zeros(ndim: usize) -> Dim<[usize; 4]>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 4]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<[usize; 4]> as Dimension>::Smaller

impl Dimension for Dim<[usize; 5]>

pub const NDIM: Option<usize>

type Pattern = (usize, usize, usize, usize, usize)

type Smaller = Dim<[usize; 4]>

type Larger = Dim<[usize; 6]>

pub fn ndim(&self) -> usize

pub fn into_pattern(self) -> <Dim<[usize; 5]> as Dimension>::Pattern

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn zeros(ndim: usize) -> Dim<[usize; 5]>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 5]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<[usize; 5]> as Dimension>::Smaller

impl Dimension for Dim<[usize; 6]>

pub const NDIM: Option<usize>

type Pattern = (usize, usize, usize, usize, usize, usize)

type Smaller = Dim<[usize; 5]>

type Larger = Dim<IxDynImpl>

pub fn ndim(&self) -> usize

pub fn into_pattern(self) -> <Dim<[usize; 6]> as Dimension>::Pattern

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn zeros(ndim: usize) -> Dim<[usize; 6]>

pub fn insert_axis(&self, axis: Axis) -> <Dim<[usize; 6]> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<[usize; 6]> as Dimension>::Smaller

impl Dimension for Dim<IxDynImpl>

IxDyn is a “dynamic” index, pretty hard to use when indexing, and memory wasteful, but it allows an arbitrary and dynamic number of axes.

pub const NDIM: Option<usize>

type Pattern = Dim<IxDynImpl>

type Smaller = Dim<IxDynImpl>

type Larger = Dim<IxDynImpl>

pub fn ndim(&self) -> usize

pub fn slice(&self) -> &[usize]

pub fn slice_mut(&mut self) -> &mut [usize]

pub fn into_pattern(self) -> <Dim<IxDynImpl> as Dimension>::Pattern

pub fn zeros(ndim: usize) -> Dim<IxDynImpl>

pub fn insert_axis(&self, axis: Axis) -> <Dim<IxDynImpl> as Dimension>::Larger

pub fn try_remove_axis(
    &self,
    axis: Axis
) -> <Dim<IxDynImpl> as Dimension>::Smaller

pub fn from_dimension<D2>(d: &D2) -> Option<Dim<IxDynImpl>> where
    D2: Dimension, 

pub fn into_dyn(self) -> Dim<IxDynImpl>