Struct nalgebra::base::dimension::Const

pub struct Const<const R: usize>;

Trait Implementations

impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>> for DefaultAllocator

type Buffer = ArrayStorage<T, R, C>

The type of buffer this allocator can instanciate.

unsafe fn allocate_uninitialized(
    _: Const<R>,
    _: Const<C>
) -> MaybeUninit<Self::Buffer>

Allocates a buffer with the given number of rows and columns without initializing its content.

fn allocate_from_iterator<I: IntoIterator<Item = T>>(
    nrows: Const<R>,
    ncols: Const<C>,
    iter: I
) -> Self::Buffer

Allocates a buffer initialized with the content of the given iterator.

impl<const R: usize> Clone for Const<R>

fn clone(&self) -> Const<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const R: usize> Debug for Const<R>

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

Formats the value using the given formatter.

impl<const T: usize> Dim for Const<T>

fn try_to_usize() -> Option<usize>

Gets the compile-time value of Self. Returns None if it is not known, i.e., if Self = Dynamic.

fn value(&self) -> usize

Gets the run-time value of self. For type-level integers, this is the same as Self::try_to_usize().unwrap().

fn from_usize(dim: usize) -> Self

Builds an instance of Self from a run-time value. Panics if Self is a type-level integer and dim != Self::try_to_usize().unwrap().

fn is<D: Dim>() -> bool

impl<const A: usize, const B: usize> DimAdd<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Add<<Const<B> as ToTypenum>::Typenum>,
    Sum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Sum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn add(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimDiv<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Div<<Const<B> as ToTypenum>::Typenum>,
    Quot<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Quot<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn div(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimMax<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Max<<Const<B> as ToTypenum>::Typenum>,
    Maximum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Maximum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn max(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimMin<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Min<<Const<B> as ToTypenum>::Typenum>,
    Minimum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Minimum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn min(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimMul<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Mul<<Const<B> as ToTypenum>::Typenum>,
    Prod<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Prod<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn mul(self, _: Const<B>) -> Self::Output

impl<const T: usize> DimName for Const<T>

const USIZE: usize

fn name() -> Self

The name of this dimension, i.e., the singleton Self.

fn dim() -> usize

The value of this dimension.

impl<const A: usize, const B: usize> DimNameAdd<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Add<<Const<B> as ToTypenum>::Typenum>,
    Sum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Sum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn add(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimNameDiv<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Div<<Const<B> as ToTypenum>::Typenum>,
    Quot<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Quot<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn div(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimNameMax<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Max<<Const<B> as ToTypenum>::Typenum>,
    Maximum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Maximum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn max(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimNameMin<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Min<<Const<B> as ToTypenum>::Typenum>,
    Minimum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Minimum<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn min(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimNameMul<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Mul<<Const<B> as ToTypenum>::Typenum>,
    Prod<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Prod<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn mul(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimNameSub<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Sub<<Const<B> as ToTypenum>::Typenum>,
    Diff<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Diff<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn sub(self, _: Const<B>) -> Self::Output

impl<const A: usize, const B: usize> DimSub<Const<B>> for Const<A> where
    Const<A>: ToTypenum,
    Const<B>: ToTypenum,
    <Const<A> as ToTypenum>::Typenum: Sub<<Const<B> as ToTypenum>::Typenum>,
    Diff<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst, 

type Output = <Diff<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const

fn sub(self, _: Const<B>) -> Self::Output

impl<const R: usize> Hash for Const<R>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<const R: usize> PartialEq<Const<R>> for Const<R>

fn eq(&self, other: &Const<R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: Scalar, CTo, const RFROM: usize, const CFROM: usize> Reallocator<T, Const<RFROM>, Const<CFROM>, Dynamic, CTo> for DefaultAllocator where
    CTo: Dim, 

unsafe fn reallocate_copy(
    rto: Dynamic,
    cto: CTo,
    buf: ArrayStorage<T, RFROM, CFROM>
) -> VecStorage<T, Dynamic, CTo>

Reallocates a buffer of shape (RTo, CTo), possibly reusing a previously allocated buffer buf. Data stored by buf are linearly copied to the output:

impl<T: Scalar, RTo, const RFROM: usize, const CFROM: usize> Reallocator<T, Const<RFROM>, Const<CFROM>, RTo, Dynamic> for DefaultAllocator where
    RTo: DimName, 

unsafe fn reallocate_copy(
    rto: RTo,
    cto: Dynamic,
    buf: ArrayStorage<T, RFROM, CFROM>
) -> VecStorage<T, RTo, Dynamic>

Reallocates a buffer of shape (RTo, CTo), possibly reusing a previously allocated buffer buf. Data stored by buf are linearly copied to the output:

impl<T: Scalar, RFrom, CFrom, const RTO: usize, const CTO: usize> Reallocator<T, RFrom, CFrom, Const<RTO>, Const<CTO>> for DefaultAllocator where
    RFrom: Dim,
    CFrom: Dim,
    Self: Allocator<T, RFrom, CFrom>, 

unsafe fn reallocate_copy(
    rto: Const<RTO>,
    cto: Const<CTO>,
    buf: <Self as Allocator<T, RFrom, CFrom>>::Buffer
) -> ArrayStorage<T, RTO, CTO>

Reallocates a buffer of shape (RTo, CTo), possibly reusing a previously allocated buffer buf. Data stored by buf are linearly copied to the output:

impl<T, const R1: usize, const C1: usize, const R2: usize, const C2: usize> ReshapableStorage<T, Const<R1>, Const<C1>, Const<R2>, Const<C2>> for ArrayStorage<T, R1, C1> where
    T: Scalar,
    Const<R1>: ToTypenum,
    Const<C1>: ToTypenum,
    Const<R2>: ToTypenum,
    Const<C2>: ToTypenum,
    <Const<R1> as ToTypenum>::Typenum: Mul<<Const<C1> as ToTypenum>::Typenum>,
    <Const<R2> as ToTypenum>::Typenum: Mul<<Const<C2> as ToTypenum>::Typenum, Output = Prod<<Const<R1> as ToTypenum>::Typenum, <Const<C1> as ToTypenum>::Typenum>>, 

type Output = ArrayStorage<T, R2, C2>

The reshaped storage type.

fn reshape_generic(self, _: Const<R2>, _: Const<C2>) -> Self::Output

Reshapes the storage into the output storage type.

impl<T, const R: usize, const C: usize> Storage<T, Const<R>, Const<C>> for ArrayStorage<T, R, C> where
    T: Scalar,
    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>, 

type RStride = Const<1>

The static stride of this storage’s rows.

type CStride = Const<R>

The static stride of this storage’s columns.

fn ptr(&self) -> *const T

The matrix data pointer.

fn shape(&self) -> (Const<R>, Const<C>)

The dimension of the matrix at run-time. Arr length of zero indicates the additive identity element of any dimension. Must be equal to Self::dimension() if it is not None.

fn strides(&self) -> (Self::RStride, Self::CStride)

The spacing between consecutive row elements and consecutive column elements.

fn is_contiguous(&self) -> bool

Indicates whether this data buffer stores its elements contiguously.

fn into_owned(self) -> Owned<T, Const<R>, Const<C>> where
    DefaultAllocator: Allocator<T, Const<R>, Const<C>>, 

Builds a matrix data storage that does not contain any reference.

fn clone_owned(&self) -> Owned<T, Const<R>, Const<C>> where
    DefaultAllocator: Allocator<T, Const<R>, Const<C>>, 

Clones this data storage to one that does not contain any reference.

fn as_slice(&self) -> &[T]

Retrieves the data buffer as a contiguous slice.

fn linear_index(&self, irow: usize, icol: usize) -> usize

Compute the index corresponding to the irow-th row and icol-th column of this matrix. The index must be such that the following holds:

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const T

Gets the address of the i-th matrix component without performing bound-checking.

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const T

Gets the address of the i-th matrix component without performing bound-checking.

unsafe fn get_unchecked_linear(&self, i: usize) -> &T

Retrieves a reference to the i-th element without bound-checking.

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &T

Retrieves a reference to the i-th element without bound-checking.

impl<T, const R: usize, const C: usize> StorageMut<T, Const<R>, Const<C>> for ArrayStorage<T, R, C> where
    T: Scalar,
    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>, 

fn ptr_mut(&mut self) -> *mut T

The matrix mutable data pointer.

fn as_mut_slice(&mut self) -> &mut [T]

Retrieves the mutable data buffer as a contiguous slice.

unsafe fn get_address_unchecked_linear_mut(&mut self, i: usize) -> *mut T

Gets the mutable address of the i-th matrix component without performing bound-checking.

unsafe fn get_address_unchecked_mut(
    &mut self,
    irow: usize,
    icol: usize
) -> *mut T

Gets the mutable address of the i-th matrix component without performing bound-checking.

unsafe fn get_unchecked_linear_mut(&mut self, i: usize) -> &mut T

Retrieves a mutable reference to the i-th element without bound-checking.

unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut T

Retrieves a mutable reference to the element at (irow, icol) without bound-checking.

unsafe fn swap_unchecked_linear(&mut self, i1: usize, i2: usize)

Swaps two elements using their linear index without bound-checking.

unsafe fn swap_unchecked(
    &mut self,
    row_col1: (usize, usize),
    row_col2: (usize, usize)
)

Swaps two elements without bound-checking.

impl ToTypenum for Const<{ typenum::U1::USIZE }>

type Typenum = U1

impl ToTypenum for Const<{ typenum::U0::USIZE }>

type Typenum = U0

impl ToTypenum for Const<{ typenum::U10::USIZE }>

type Typenum = U10

impl ToTypenum for Const<{ typenum::U100::USIZE }>

type Typenum = U100

impl ToTypenum for Const<{ typenum::U101::USIZE }>

type Typenum = U101

impl ToTypenum for Const<{ typenum::U102::USIZE }>

type Typenum = U102

impl ToTypenum for Const<{ typenum::U103::USIZE }>

type Typenum = U103

impl ToTypenum for Const<{ typenum::U104::USIZE }>

type Typenum = U104

impl ToTypenum for Const<{ typenum::U105::USIZE }>

type Typenum = U105

impl ToTypenum for Const<{ typenum::U106::USIZE }>

type Typenum = U106

impl ToTypenum for Const<{ typenum::U107::USIZE }>

type Typenum = U107

impl ToTypenum for Const<{ typenum::U108::USIZE }>

type Typenum = U108

impl ToTypenum for Const<{ typenum::U109::USIZE }>

type Typenum = U109

impl ToTypenum for Const<{ typenum::U11::USIZE }>

type Typenum = U11

impl ToTypenum for Const<{ typenum::U110::USIZE }>

type Typenum = U110

impl ToTypenum for Const<{ typenum::U111::USIZE }>

type Typenum = U111

impl ToTypenum for Const<{ typenum::U112::USIZE }>

type Typenum = U112

impl ToTypenum for Const<{ typenum::U113::USIZE }>

type Typenum = U113

impl ToTypenum for Const<{ typenum::U114::USIZE }>

type Typenum = U114

impl ToTypenum for Const<{ typenum::U115::USIZE }>

type Typenum = U115

impl ToTypenum for Const<{ typenum::U116::USIZE }>

type Typenum = U116

impl ToTypenum for Const<{ typenum::U117::USIZE }>

type Typenum = U117

impl ToTypenum for Const<{ typenum::U118::USIZE }>

type Typenum = U118

impl ToTypenum for Const<{ typenum::U119::USIZE }>

type Typenum = U119

impl ToTypenum for Const<{ typenum::U12::USIZE }>

type Typenum = U12

impl ToTypenum for Const<{ typenum::U120::USIZE }>

type Typenum = U120

impl ToTypenum for Const<{ typenum::U121::USIZE }>

type Typenum = U121

impl ToTypenum for Const<{ typenum::U122::USIZE }>

type Typenum = U122

impl ToTypenum for Const<{ typenum::U123::USIZE }>

type Typenum = U123

impl ToTypenum for Const<{ typenum::U124::USIZE }>

type Typenum = U124

impl ToTypenum for Const<{ typenum::U125::USIZE }>

type Typenum = U125

impl ToTypenum for Const<{ typenum::U126::USIZE }>

type Typenum = U126

impl ToTypenum for Const<{ typenum::U127::USIZE }>

type Typenum = U127

impl ToTypenum for Const<{ typenum::U13::USIZE }>

type Typenum = U13

impl ToTypenum for Const<{ typenum::U14::USIZE }>

type Typenum = U14

impl ToTypenum for Const<{ typenum::U15::USIZE }>

type Typenum = U15

impl ToTypenum for Const<{ typenum::U16::USIZE }>

type Typenum = U16

impl ToTypenum for Const<{ typenum::U17::USIZE }>

type Typenum = U17

impl ToTypenum for Const<{ typenum::U18::USIZE }>

type Typenum = U18

impl ToTypenum for Const<{ typenum::U19::USIZE }>

type Typenum = U19

impl ToTypenum for Const<{ typenum::U2::USIZE }>

type Typenum = U2

impl ToTypenum for Const<{ typenum::U20::USIZE }>

type Typenum = U20

impl ToTypenum for Const<{ typenum::U21::USIZE }>

type Typenum = U21

impl ToTypenum for Const<{ typenum::U22::USIZE }>

type Typenum = U22

impl ToTypenum for Const<{ typenum::U23::USIZE }>

type Typenum = U23

impl ToTypenum for Const<{ typenum::U24::USIZE }>

type Typenum = U24

impl ToTypenum for Const<{ typenum::U25::USIZE }>

type Typenum = U25

impl ToTypenum for Const<{ typenum::U26::USIZE }>

type Typenum = U26

impl ToTypenum for Const<{ typenum::U27::USIZE }>

type Typenum = U27

impl ToTypenum for Const<{ typenum::U28::USIZE }>

type Typenum = U28

impl ToTypenum for Const<{ typenum::U29::USIZE }>

type Typenum = U29

impl ToTypenum for Const<{ typenum::U3::USIZE }>

type Typenum = U3

impl ToTypenum for Const<{ typenum::U30::USIZE }>

type Typenum = U30

impl ToTypenum for Const<{ typenum::U31::USIZE }>

type Typenum = U31

impl ToTypenum for Const<{ typenum::U32::USIZE }>

type Typenum = U32

impl ToTypenum for Const<{ typenum::U33::USIZE }>

type Typenum = U33

impl ToTypenum for Const<{ typenum::U34::USIZE }>

type Typenum = U34

impl ToTypenum for Const<{ typenum::U35::USIZE }>

type Typenum = U35

impl ToTypenum for Const<{ typenum::U36::USIZE }>

type Typenum = U36

impl ToTypenum for Const<{ typenum::U37::USIZE }>

type Typenum = U37

impl ToTypenum for Const<{ typenum::U38::USIZE }>

type Typenum = U38

impl ToTypenum for Const<{ typenum::U39::USIZE }>

type Typenum = U39

impl ToTypenum for Const<{ typenum::U4::USIZE }>

type Typenum = U4

impl ToTypenum for Const<{ typenum::U40::USIZE }>

type Typenum = U40

impl ToTypenum for Const<{ typenum::U41::USIZE }>

type Typenum = U41

impl ToTypenum for Const<{ typenum::U42::USIZE }>

type Typenum = U42

impl ToTypenum for Const<{ typenum::U43::USIZE }>

type Typenum = U43

impl ToTypenum for Const<{ typenum::U44::USIZE }>

type Typenum = U44

impl ToTypenum for Const<{ typenum::U45::USIZE }>

type Typenum = U45

impl ToTypenum for Const<{ typenum::U46::USIZE }>

type Typenum = U46

impl ToTypenum for Const<{ typenum::U47::USIZE }>

type Typenum = U47

impl ToTypenum for Const<{ typenum::U48::USIZE }>

type Typenum = U48

impl ToTypenum for Const<{ typenum::U49::USIZE }>

type Typenum = U49

impl ToTypenum for Const<{ typenum::U5::USIZE }>

type Typenum = U5

impl ToTypenum for Const<{ typenum::U50::USIZE }>

type Typenum = U50

impl ToTypenum for Const<{ typenum::U51::USIZE }>

type Typenum = U51

impl ToTypenum for Const<{ typenum::U52::USIZE }>

type Typenum = U52

impl ToTypenum for Const<{ typenum::U53::USIZE }>

type Typenum = U53

impl ToTypenum for Const<{ typenum::U54::USIZE }>

type Typenum = U54

impl ToTypenum for Const<{ typenum::U55::USIZE }>

type Typenum = U55

impl ToTypenum for Const<{ typenum::U56::USIZE }>

type Typenum = U56

impl ToTypenum for Const<{ typenum::U57::USIZE }>

type Typenum = U57

impl ToTypenum for Const<{ typenum::U58::USIZE }>

type Typenum = U58

impl ToTypenum for Const<{ typenum::U59::USIZE }>

type Typenum = U59

impl ToTypenum for Const<{ typenum::U6::USIZE }>

type Typenum = U6

impl ToTypenum for Const<{ typenum::U60::USIZE }>

type Typenum = U60

impl ToTypenum for Const<{ typenum::U61::USIZE }>

type Typenum = U61

impl ToTypenum for Const<{ typenum::U62::USIZE }>

type Typenum = U62

impl ToTypenum for Const<{ typenum::U63::USIZE }>

type Typenum = U63

impl ToTypenum for Const<{ typenum::U64::USIZE }>

type Typenum = U64

impl ToTypenum for Const<{ typenum::U65::USIZE }>

type Typenum = U65

impl ToTypenum for Const<{ typenum::U66::USIZE }>

type Typenum = U66

impl ToTypenum for Const<{ typenum::U67::USIZE }>

type Typenum = U67

impl ToTypenum for Const<{ typenum::U68::USIZE }>

type Typenum = U68

impl ToTypenum for Const<{ typenum::U69::USIZE }>

type Typenum = U69

impl ToTypenum for Const<{ typenum::U7::USIZE }>

type Typenum = U7

impl ToTypenum for Const<{ typenum::U70::USIZE }>

type Typenum = U70

impl ToTypenum for Const<{ typenum::U71::USIZE }>

type Typenum = U71

impl ToTypenum for Const<{ typenum::U72::USIZE }>

type Typenum = U72

impl ToTypenum for Const<{ typenum::U73::USIZE }>

type Typenum = U73

impl ToTypenum for Const<{ typenum::U74::USIZE }>

type Typenum = U74

impl ToTypenum for Const<{ typenum::U75::USIZE }>

type Typenum = U75

impl ToTypenum for Const<{ typenum::U76::USIZE }>

type Typenum = U76

impl ToTypenum for Const<{ typenum::U77::USIZE }>

type Typenum = U77

impl ToTypenum for Const<{ typenum::U78::USIZE }>

type Typenum = U78

impl ToTypenum for Const<{ typenum::U79::USIZE }>

type Typenum = U79

impl ToTypenum for Const<{ typenum::U8::USIZE }>

type Typenum = U8

impl ToTypenum for Const<{ typenum::U80::USIZE }>

type Typenum = U80

impl ToTypenum for Const<{ typenum::U81::USIZE }>

type Typenum = U81

impl ToTypenum for Const<{ typenum::U82::USIZE }>

type Typenum = U82

impl ToTypenum for Const<{ typenum::U83::USIZE }>

type Typenum = U83

impl ToTypenum for Const<{ typenum::U84::USIZE }>

type Typenum = U84

impl ToTypenum for Const<{ typenum::U85::USIZE }>

type Typenum = U85

impl ToTypenum for Const<{ typenum::U86::USIZE }>

type Typenum = U86

impl ToTypenum for Const<{ typenum::U87::USIZE }>

type Typenum = U87

impl ToTypenum for Const<{ typenum::U88::USIZE }>

type Typenum = U88

impl ToTypenum for Const<{ typenum::U89::USIZE }>

type Typenum = U89

impl ToTypenum for Const<{ typenum::U9::USIZE }>

type Typenum = U9

impl ToTypenum for Const<{ typenum::U90::USIZE }>

type Typenum = U90

impl ToTypenum for Const<{ typenum::U91::USIZE }>

type Typenum = U91

impl ToTypenum for Const<{ typenum::U92::USIZE }>

type Typenum = U92

impl ToTypenum for Const<{ typenum::U93::USIZE }>

type Typenum = U93

impl ToTypenum for Const<{ typenum::U94::USIZE }>

type Typenum = U94

impl ToTypenum for Const<{ typenum::U95::USIZE }>

type Typenum = U95

impl ToTypenum for Const<{ typenum::U96::USIZE }>

type Typenum = U96

impl ToTypenum for Const<{ typenum::U97::USIZE }>

type Typenum = U97

impl ToTypenum for Const<{ typenum::U98::USIZE }>

type Typenum = U98

impl ToTypenum for Const<{ typenum::U99::USIZE }>

type Typenum = U99

impl<T, const R: usize, const C: usize> ContiguousStorage<T, Const<R>, Const<C>> for ArrayStorage<T, R, C> where
    T: Scalar,
    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>, 

impl<'a, T: Scalar, R: Dim, CStride: Dim> ContiguousStorage<T, R, Const<1_usize>> for SliceStorage<'a, T, R, U1, U1, CStride>

impl<'a, T: Scalar, R: Dim, CStride: Dim> ContiguousStorage<T, R, Const<1_usize>> for SliceStorageMut<'a, T, R, U1, U1, CStride>

impl<T, const R: usize, const C: usize> ContiguousStorageMut<T, Const<R>, Const<C>> for ArrayStorage<T, R, C> where
    T: Scalar,
    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>, 

impl<'a, T: Scalar, R: Dim, CStride: Dim> ContiguousStorageMut<T, R, Const<1_usize>> for SliceStorageMut<'a, T, R, U1, U1, CStride>

impl<const R: usize> Copy for Const<R>

impl<const R: usize> Eq for Const<R>

impl<const R: usize> StructuralEq for Const<R>

impl<const R: usize> StructuralPartialEq for Const<R>