Struct Dim 

pub struct Dim<L, T, M, Th, I, N, J, A>(/* private fields */)
where
    L: Integer,
    T: Integer,
    M: Integer,
    Th: Integer,
    I: Integer,
    N: Integer,
    J: Integer,
    A: Integer;

A physical dimension encoded as eight typenum integer exponents.

This is a zero-sized type: no runtime cost.

Trait Implementations

impl<L, T, M, Th, I, N, J, A> Clone for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + Clone, T: Integer + Clone, M: Integer + Clone, Th: Integer + Clone, I: Integer + Clone, N: Integer + Clone, J: Integer + Clone, A: Integer + Clone,

fn clone(&self) -> Dim<L, T, M, Th, I, N, J, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L, T, M, Th, I, N, J, A> Debug for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + Debug, T: Integer + Debug, M: Integer + Debug, Th: Integer + Debug, I: Integer + Debug, N: Integer + Debug, J: Integer + Debug, A: Integer + Debug,

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

Formats the value using the given formatter.

impl<L1, T1, M1, Th1, I1, N1, J1, A1, L2, T2, M2, Th2, I2, N2, J2, A2> DimDiv<Dim<L2, T2, M2, Th2, I2, N2, J2, A2>> for Dim<L1, T1, M1, Th1, I1, N1, J1, A1>

where L1: Integer + Sub<L2> + 'static, T1: Integer + Sub<T2> + 'static, M1: Integer + Sub<M2> + 'static, Th1: Integer + Sub<Th2> + 'static, I1: Integer + Sub<I2> + 'static, N1: Integer + Sub<N2> + 'static, J1: Integer + Sub<J2> + 'static, A1: Integer + Sub<A2> + 'static, L2: Integer + 'static, T2: Integer + 'static, M2: Integer + 'static, Th2: Integer + 'static, I2: Integer + 'static, N2: Integer + 'static, J2: Integer + 'static, A2: Integer + 'static, <L1 as Sub<L2>>::Output: Integer + 'static, <T1 as Sub<T2>>::Output: Integer + 'static, <M1 as Sub<M2>>::Output: Integer + 'static, <Th1 as Sub<Th2>>::Output: Integer + 'static, <I1 as Sub<I2>>::Output: Integer + 'static, <N1 as Sub<N2>>::Output: Integer + 'static, <J1 as Sub<J2>>::Output: Integer + 'static, <A1 as Sub<A2>>::Output: Integer + 'static,

type Output = Dim<<L1 as Sub<L2>>::Output, <T1 as Sub<T2>>::Output, <M1 as Sub<M2>>::Output, <Th1 as Sub<Th2>>::Output, <I1 as Sub<I2>>::Output, <N1 as Sub<N2>>::Output, <J1 as Sub<J2>>::Output, <A1 as Sub<A2>>::Output>

The resulting dimension.

impl<L1, T1, M1, Th1, I1, N1, J1, A1, L2, T2, M2, Th2, I2, N2, J2, A2> DimMul<Dim<L2, T2, M2, Th2, I2, N2, J2, A2>> for Dim<L1, T1, M1, Th1, I1, N1, J1, A1>

where L1: Integer + Add<L2> + 'static, T1: Integer + Add<T2> + 'static, M1: Integer + Add<M2> + 'static, Th1: Integer + Add<Th2> + 'static, I1: Integer + Add<I2> + 'static, N1: Integer + Add<N2> + 'static, J1: Integer + Add<J2> + 'static, A1: Integer + Add<A2> + 'static, L2: Integer + 'static, T2: Integer + 'static, M2: Integer + 'static, Th2: Integer + 'static, I2: Integer + 'static, N2: Integer + 'static, J2: Integer + 'static, A2: Integer + 'static, <L1 as Add<L2>>::Output: Integer + 'static, <T1 as Add<T2>>::Output: Integer + 'static, <M1 as Add<M2>>::Output: Integer + 'static, <Th1 as Add<Th2>>::Output: Integer + 'static, <I1 as Add<I2>>::Output: Integer + 'static, <N1 as Add<N2>>::Output: Integer + 'static, <J1 as Add<J2>>::Output: Integer + 'static, <A1 as Add<A2>>::Output: Integer + 'static,

type Output = Dim<<L1 as Add<L2>>::Output, <T1 as Add<T2>>::Output, <M1 as Add<M2>>::Output, <Th1 as Add<Th2>>::Output, <I1 as Add<I2>>::Output, <N1 as Add<N2>>::Output, <J1 as Add<J2>>::Output, <A1 as Add<A2>>::Output>

The resulting dimension.

impl<L, T, M, Th, I, N, J, A> PartialEq for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + PartialEq, T: Integer + PartialEq, M: Integer + PartialEq, Th: Integer + PartialEq, I: Integer + PartialEq, N: Integer + PartialEq, J: Integer + PartialEq, A: Integer + PartialEq,

fn eq(&self, other: &Dim<L, T, M, Th, I, N, J, A>) -> 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<L, T, M, Th, I, N, J, A> Copy for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + Copy, T: Integer + Copy, M: Integer + Copy, Th: Integer + Copy, I: Integer + Copy, N: Integer + Copy, J: Integer + Copy, A: Integer + Copy,

impl<L, T, M, Th, I, N, J, A> Dimension for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + 'static, T: Integer + 'static, M: Integer + 'static, Th: Integer + 'static, I: Integer + 'static, N: Integer + 'static, J: Integer + 'static, A: Integer + 'static,

impl<L, T, M, Th, I, N, J, A> Eq for Dim<L, T, M, Th, I, N, J, A>

where L: Integer + Eq, T: Integer + Eq, M: Integer + Eq, Th: Integer + Eq, I: Integer + Eq, N: Integer + Eq, J: Integer + Eq, A: Integer + Eq,

impl<L, T, M, Th, I, N, J, A> StructuralPartialEq for Dim<L, T, M, Th, I, N, J, A>

where L: Integer, T: Integer, M: Integer, Th: Integer, I: Integer, N: Integer, J: Integer, A: Integer,