Type Alias Ix0

pub type Ix0 = Dim<[usize; 0]>;

zero-dimensionial

Aliased Type

struct Ix0 { /* private fields */ }

Trait Implementations

impl<I> Add for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the + operator.

fn add(self, rhs: Dim<I>) -> Dim<I>

Performs the + operation.

impl<'a, I> AddAssign<&'a Dim<I>> for Dim<I>

where Dim<I>: Dimension,

fn add_assign(&mut self, rhs: &Dim<I>)

Performs the += operation.

impl<I> AddAssign for Dim<I>

where Dim<I>: Dimension,

fn add_assign(&mut self, rhs: Dim<I>)

Performs the += operation.

impl<I> Clone for Dim<I>

where I: Clone + ?Sized,

fn clone(&self) -> Dim<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Dim<I>

where I: Debug,

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

Formats the value using the given formatter.

impl<I> Default for Dim<I>

where I: Default + ?Sized,

fn default() -> Dim<I>

Returns the “default value” for a type.

impl<D> DimAdd<D> for Dim<[usize; 0]>

where D: Dimension,

type Output = D

The sum of the two dimensions.

impl DimMax<Dim<[usize; 1]>> for Dim<[usize; 0]>

type Output = Dim<[usize; 1]>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 2]>> for Dim<[usize; 0]>

type Output = Dim<[usize; 2]>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 3]>> for Dim<[usize; 0]>

type Output = Dim<[usize; 3]>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 4]>> for Dim<[usize; 0]>

type Output = Dim<[usize; 4]>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 5]>> for Dim<[usize; 0]>

type Output = Dim<[usize; 5]>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 6]>> for Dim<[usize; 0]>

type Output = Dim<[usize; 6]>

The resulting dimension type after broadcasting.

impl DimMax<Dim<IxDynImpl>> for Dim<[usize; 0]>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl Dimension for Dim<[usize; 0]>

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.

type Pattern = ()

Pattern matching friendly form of the dimension value.

type Smaller = Dim<[usize; 0]>

Next smaller dimension (if applicable)

type Larger = Dim<[usize; 1]>

Next larger dimension

fn ndim(&self) -> usize

Returns the number of dimensions (number of axes).

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

Convert the dimension into a pattern matching friendly value.

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

Creates a dimension of all zeros with the specified ndim.

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).

impl<I> Hash for Dim<I>

where I: Hash + ?Sized,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for Dim<[usize; 0]>

type Output = usize

The returned type after indexing.

fn index(&self, index: usize) -> &<Dim<[usize; 0]> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Dim<[usize; 0]>

fn index_mut( &mut self, index: usize, ) -> &mut <Dim<[usize; 0]> as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl<I> Mul<usize> for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Dim<I>

Performs the * operation.

impl<I> Mul for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the * operator.

fn mul(self, rhs: Dim<I>) -> Dim<I>

Performs the * operation.

impl<'a, I> MulAssign<&'a Dim<I>> for Dim<I>

where Dim<I>: Dimension,

fn mul_assign(&mut self, rhs: &Dim<I>)

Performs the *= operation.

impl<I> MulAssign<usize> for Dim<I>

where Dim<I>: Dimension,

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<I> MulAssign for Dim<I>

where Dim<I>: Dimension,

fn mul_assign(&mut self, rhs: Dim<I>)

Performs the *= operation.

impl<I> PartialEq<I> for Dim<I>

where I: PartialEq + ?Sized,

fn eq(&self, rhs: &I) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> PartialEq for Dim<I>

where I: PartialEq + ?Sized,

fn eq(&self, other: &Dim<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> Sub for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the - operator.

fn sub(self, rhs: Dim<I>) -> Dim<I>

Performs the - operation.

impl<'a, I> SubAssign<&'a Dim<I>> for Dim<I>

where Dim<I>: Dimension,

fn sub_assign(&mut self, rhs: &Dim<I>)

Performs the -= operation.

impl<I> SubAssign for Dim<I>

where Dim<I>: Dimension,

fn sub_assign(&mut self, rhs: Dim<I>)

Performs the -= operation.

impl Zero for Dim<[usize; 0]>

fn zero() -> Dim<[usize; 0]>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<I> Copy for Dim<I>

where I: Copy + ?Sized,

impl<I> Eq for Dim<I>

where I: Eq + ?Sized,

impl<const N: usize> NdIndex<Dim<IxDynImpl>> for Dim<[usize; N]>

impl<I> StructuralPartialEq for Dim<I>

where I: ?Sized,