Struct dimensioned::unit_systems::ucum::UCUM [−][src]
pub struct UCUM<V, U> { pub value_unsafe: V, pub _marker: PhantomData<U>, }
The struct for this unit system
Fields
value_unsafe: V
This is the value of whatever type we're giving units. Using it directly bypasses all of the dimensional analysis that having a unit system provides, and should be avoided whenever possible.
If using this member is necessary, it is strongly encouraged to wrap the calculation in a dimensionally-safe interface.
_marker: PhantomData<U>
This member is only temporarily public and so its use is considered unstable.
Right now, the only way to create a const
with units is with this pattern:
extern crate dimensioned as dim; use dim::si; const x: si::Meter<f64> = si::Meter { value_unsafe: 3.4, _marker: std::marker::PhantomData };
Once const_fns
is stabilized, that will be able to be replaced with a call to
Meter::new
and _marker
will be made private.
Methods
impl<V, U> UCUM<V, U>
[src]
impl<V, U> UCUM<V, U>
Trait Implementations
impl<V: Eq, U: Eq> Eq for UCUM<V, U>
[src]
impl<V: Eq, U: Eq> Eq for UCUM<V, U>
impl<V: PartialEq, U: PartialEq> PartialEq for UCUM<V, U>
[src]
impl<V: PartialEq, U: PartialEq> PartialEq for UCUM<V, U>
fn eq(&self, other: &UCUM<V, U>) -> bool
[src]
fn eq(&self, other: &UCUM<V, U>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &UCUM<V, U>) -> bool
[src]
fn ne(&self, other: &UCUM<V, U>) -> bool
This method tests for !=
.
impl<V: Ord, U: Ord> Ord for UCUM<V, U>
[src]
impl<V: Ord, U: Ord> Ord for UCUM<V, U>
fn cmp(&self, other: &UCUM<V, U>) -> Ordering
[src]
fn cmp(&self, other: &UCUM<V, U>) -> Ordering
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.21.0[src]
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
impl<V: PartialOrd, U: PartialOrd> PartialOrd for UCUM<V, U>
[src]
impl<V: PartialOrd, U: PartialOrd> PartialOrd for UCUM<V, U>
fn partial_cmp(&self, other: &UCUM<V, U>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &UCUM<V, U>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &UCUM<V, U>) -> bool
[src]
fn lt(&self, other: &UCUM<V, U>) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &UCUM<V, U>) -> bool
[src]
fn le(&self, other: &UCUM<V, U>) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &UCUM<V, U>) -> bool
[src]
fn gt(&self, other: &UCUM<V, U>) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &UCUM<V, U>) -> bool
[src]
fn ge(&self, other: &UCUM<V, U>) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<V: Clone, U: Clone> Clone for UCUM<V, U>
[src]
impl<V: Clone, U: Clone> Clone for UCUM<V, U>
fn clone(&self) -> UCUM<V, U>
[src]
fn clone(&self) -> UCUM<V, U>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<V: Copy, U: Copy> Copy for UCUM<V, U>
[src]
impl<V: Copy, U: Copy> Copy for UCUM<V, U>
impl<V: Hash, U: Hash> Hash for UCUM<V, U>
[src]
impl<V: Hash, U: Hash> Hash for UCUM<V, U>
fn hash<__HVU: Hasher>(&self, state: &mut __HVU)
[src]
fn hash<__HVU: Hasher>(&self, state: &mut __HVU)
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<V, U> Dimensioned for UCUM<V, U>
[src]
impl<V, U> Dimensioned for UCUM<V, U>
type Value = V
The type of the value of a quantity. E.g. For si::Meter<f64>
, Value
is f64
.
type Units = U
The units of a quanitity. This will be a type-array of type-numbers. E.g. For si::Meter<f64>
, Units
is tarr![P1, Z0, Z0, Z0, Z0, Z0, Z0]
. Read more
fn new(val: V) -> Self
[src]
fn new(val: V) -> Self
Construct a new quantity.
ⓘImportant traits for &'a mut Rfn value_unsafe(&self) -> &V
[src]
fn value_unsafe(&self) -> &V
Extract the value from a quantity. As this ignores the units completely, it is dimensionally unsafe. Read more
impl<ValueIn, UnitsIn, ValueOut, UnitsOut> MapUnsafe<ValueOut, UnitsOut> for UCUM<ValueIn, UnitsIn>
[src]
impl<ValueIn, UnitsIn, ValueOut, UnitsOut> MapUnsafe<ValueOut, UnitsOut> for UCUM<ValueIn, UnitsIn>
type Output = UCUM<ValueOut, UnitsOut>
The type to which the input is mapped
fn map_unsafe<F: FnOnce(ValueIn) -> ValueOut>(self, f: F) -> Self::Output
[src]
fn map_unsafe<F: FnOnce(ValueIn) -> ValueOut>(self, f: F) -> Self::Output
Perform the map
impl<V, U> Debug for UCUM<V, U> where
V: Debug,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> Debug for UCUM<V, U> where
V: Debug,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter. Read more
impl<V, U> Display for UCUM<V, U> where
V: Display,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> Display for UCUM<V, U> where
V: Display,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter. Read more
impl<V, U> Octal for UCUM<V, U> where
V: Octal,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> Octal for UCUM<V, U> where
V: Octal,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> LowerHex for UCUM<V, U> where
V: LowerHex,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> LowerHex for UCUM<V, U> where
V: LowerHex,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> UpperHex for UCUM<V, U> where
V: UpperHex,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> UpperHex for UCUM<V, U> where
V: UpperHex,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> Pointer for UCUM<V, U> where
V: Pointer,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> Pointer for UCUM<V, U> where
V: Pointer,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> Binary for UCUM<V, U> where
V: Binary,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> Binary for UCUM<V, U> where
V: Binary,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> LowerExp for UCUM<V, U> where
V: LowerExp,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> LowerExp for UCUM<V, U> where
V: LowerExp,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> UpperExp for UCUM<V, U> where
V: UpperExp,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
[src]
impl<V, U> UpperExp for UCUM<V, U> where
V: UpperExp,
Length<U>: ArrayLength<isize>,
U: TypeArray + Len + ToGA<Output = GenericArray<isize, Length<U>>>,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<V, U> Recip for UCUM<V, U> where
V: Recip,
U: Neg,
[src]
impl<V, U> Recip for UCUM<V, U> where
V: Recip,
U: Neg,
type Output = UCUM<<V as Recip>::Output, Negate<U>>
The resulting type after taking the reciprocal
fn recip(self) -> Self::Output
[src]
fn recip(self) -> Self::Output
The method for taking the reciprocal
impl<V: Abs, U> Abs for UCUM<V, U>
[src]
impl<V: Abs, U> Abs for UCUM<V, U>
impl<Exp, V, U> Pow<Exp> for UCUM<V, U> where
V: Pow<Exp>,
U: Mul<Exp>,
[src]
impl<Exp, V, U> Pow<Exp> for UCUM<V, U> where
V: Pow<Exp>,
U: Mul<Exp>,
type Output = UCUM<<V as Pow<Exp>>::Output, Prod<U, Exp>>
The result of the exponentiation.
fn powi(self, exp: Exp) -> Self::Output
[src]
fn powi(self, exp: Exp) -> Self::Output
This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more
impl<Index, V, U> Root<Index> for UCUM<V, U> where
V: Root<Index>,
U: PartialDiv<Index>,
[src]
impl<Index, V, U> Root<Index> for UCUM<V, U> where
V: Root<Index>,
U: PartialDiv<Index>,
type Output = UCUM<<V as Root<Index>>::Output, PartialQuot<U, Index>>
The resulting type after taking the Index
root
fn root(self, idx: Index) -> Self::Output
[src]
fn root(self, idx: Index) -> Self::Output
The method for taking the idx
root
impl<V, U> Sqrt for UCUM<V, U> where
V: Sqrt,
U: PartialDiv<P2>,
[src]
impl<V, U> Sqrt for UCUM<V, U> where
V: Sqrt,
U: PartialDiv<P2>,
type Output = UCUM<<V as Sqrt>::Output, PartialQuot<U, P2>>
The resulting type after taking the square root
fn sqrt(self) -> Self::Output
[src]
fn sqrt(self) -> Self::Output
The method for taking the square root
impl<V, U> Cbrt for UCUM<V, U> where
V: Cbrt,
U: PartialDiv<P3>,
[src]
impl<V, U> Cbrt for UCUM<V, U> where
V: Cbrt,
U: PartialDiv<P3>,
type Output = UCUM<<V as Cbrt>::Output, PartialQuot<U, P3>>
The resulting type after taking the cube root
fn cbrt(self) -> Self::Output
[src]
fn cbrt(self) -> Self::Output
The method for taking the cube root
impl<V, U> Not for UCUM<V, U> where
V: Not,
[src]
impl<V, U> Not for UCUM<V, U> where
V: Not,
type Output = UCUM<<V as Not>::Output, U>
The resulting type after applying the !
operator.
fn not(self) -> Self::Output
[src]
fn not(self) -> Self::Output
Performs the unary !
operation.
impl<V, U> Neg for UCUM<V, U> where
V: Neg,
[src]
impl<V, U> Neg for UCUM<V, U> where
V: Neg,
type Output = UCUM<<V as Neg>::Output, U>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
fn neg(self) -> Self::Output
Performs the unary -
operation.
impl<Vl, U, Vr> Add<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: Add<Vr>,
[src]
impl<Vl, U, Vr> Add<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: Add<Vr>,
type Output = UCUM<<Vl as Add<Vr>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<Vr, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<Vr, U>) -> Self::Output
Performs the +
operation.
impl<Vl, U, Vr> AddAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: AddAssign<Vr>,
[src]
impl<Vl, U, Vr> AddAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: AddAssign<Vr>,
fn add_assign(&mut self, rhs: UCUM<Vr, U>)
[src]
fn add_assign(&mut self, rhs: UCUM<Vr, U>)
Performs the +=
operation.
impl<Vl, U, Vr> Sub<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: Sub<Vr>,
[src]
impl<Vl, U, Vr> Sub<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: Sub<Vr>,
type Output = UCUM<<Vl as Sub<Vr>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<Vr, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<Vr, U>) -> Self::Output
Performs the -
operation.
impl<Vl, U, Vr> SubAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: SubAssign<Vr>,
[src]
impl<Vl, U, Vr> SubAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: SubAssign<Vr>,
fn sub_assign(&mut self, rhs: UCUM<Vr, U>)
[src]
fn sub_assign(&mut self, rhs: UCUM<Vr, U>)
Performs the -=
operation.
impl<Vl, U, Vr> BitAnd<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitAnd<Vr>,
[src]
impl<Vl, U, Vr> BitAnd<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitAnd<Vr>,
type Output = UCUM<<Vl as BitAnd<Vr>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<Vr, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<Vr, U>) -> Self::Output
Performs the &
operation.
impl<Vl, U, Vr> BitAndAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitAndAssign<Vr>,
[src]
impl<Vl, U, Vr> BitAndAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitAndAssign<Vr>,
fn bitand_assign(&mut self, rhs: UCUM<Vr, U>)
[src]
fn bitand_assign(&mut self, rhs: UCUM<Vr, U>)
Performs the &=
operation.
impl<Vl, U, Vr> BitOr<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitOr<Vr>,
[src]
impl<Vl, U, Vr> BitOr<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitOr<Vr>,
type Output = UCUM<<Vl as BitOr<Vr>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<Vr, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<Vr, U>) -> Self::Output
Performs the |
operation.
impl<Vl, U, Vr> BitOrAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitOrAssign<Vr>,
[src]
impl<Vl, U, Vr> BitOrAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitOrAssign<Vr>,
fn bitor_assign(&mut self, rhs: UCUM<Vr, U>)
[src]
fn bitor_assign(&mut self, rhs: UCUM<Vr, U>)
Performs the |=
operation.
impl<Vl, U, Vr> BitXor<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitXor<Vr>,
[src]
impl<Vl, U, Vr> BitXor<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitXor<Vr>,
type Output = UCUM<<Vl as BitXor<Vr>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<Vr, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<Vr, U>) -> Self::Output
Performs the ^
operation.
impl<Vl, U, Vr> BitXorAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitXorAssign<Vr>,
[src]
impl<Vl, U, Vr> BitXorAssign<UCUM<Vr, U>> for UCUM<Vl, U> where
Vl: BitXorAssign<Vr>,
fn bitxor_assign(&mut self, rhs: UCUM<Vr, U>)
[src]
fn bitxor_assign(&mut self, rhs: UCUM<Vr, U>)
Performs the ^=
operation.
impl<Vl, Ul, Vr, Ur> Mul<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Mul<Vr>,
Ul: Add<Ur>,
[src]
impl<Vl, Ul, Vr, Ur> Mul<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Mul<Vr>,
Ul: Add<Ur>,
type Output = UCUM<<Vl as Mul<Vr>>::Output, <Ul as Add<Ur>>::Output>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<Vr, Ur>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<Vr, Ur>) -> Self::Output
Performs the *
operation.
impl<Vl, Ul, Vr, Ur> MulAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: MulAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
[src]
impl<Vl, Ul, Vr, Ur> MulAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: MulAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
fn mul_assign(&mut self, rhs: UCUM<Vr, Ur>)
[src]
fn mul_assign(&mut self, rhs: UCUM<Vr, Ur>)
Performs the *=
operation.
impl<Vl, Ul, Vr, Ur> Div<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Div<Vr>,
Ul: Sub<Ur>,
[src]
impl<Vl, Ul, Vr, Ur> Div<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Div<Vr>,
Ul: Sub<Ur>,
type Output = UCUM<<Vl as Div<Vr>>::Output, <Ul as Sub<Ur>>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<Vr, Ur>) -> Self::Output
[src]
fn div(self, rhs: UCUM<Vr, Ur>) -> Self::Output
Performs the /
operation.
impl<Vl, Ul, Vr, Ur> DivAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: DivAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
[src]
impl<Vl, Ul, Vr, Ur> DivAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: DivAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
fn div_assign(&mut self, rhs: UCUM<Vr, Ur>)
[src]
fn div_assign(&mut self, rhs: UCUM<Vr, Ur>)
Performs the /=
operation.
impl<Vl, Ul, Vr, Ur> Rem<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Rem<Vr>,
[src]
impl<Vl, Ul, Vr, Ur> Rem<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Rem<Vr>,
type Output = UCUM<<Vl as Rem<Vr>>::Output, Ul>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<Vr, Ur>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<Vr, Ur>) -> Self::Output
Performs the %
operation.
impl<Vl, Ul, Vr, Ur> RemAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: RemAssign<Vr>,
[src]
impl<Vl, Ul, Vr, Ur> RemAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: RemAssign<Vr>,
fn rem_assign(&mut self, rhs: UCUM<Vr, Ur>)
[src]
fn rem_assign(&mut self, rhs: UCUM<Vr, Ur>)
Performs the %=
operation.
impl<Vl, Ul, Vr, Ur> Shl<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Shl<Vr>,
UCUM<Vr, Ur>: Dimensionless,
[src]
impl<Vl, Ul, Vr, Ur> Shl<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Shl<Vr>,
UCUM<Vr, Ur>: Dimensionless,
type Output = UCUM<<Vl as Shl<Vr>>::Output, Ul>
The resulting type after applying the <<
operator.
fn shl(self, rhs: UCUM<Vr, Ur>) -> Self::Output
[src]
fn shl(self, rhs: UCUM<Vr, Ur>) -> Self::Output
Performs the <<
operation.
impl<Vl, Ul, Vr, Ur> ShlAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: ShlAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
[src]
impl<Vl, Ul, Vr, Ur> ShlAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: ShlAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
fn shl_assign(&mut self, rhs: UCUM<Vr, Ur>)
[src]
fn shl_assign(&mut self, rhs: UCUM<Vr, Ur>)
Performs the <<=
operation.
impl<Vl, Ul, Vr, Ur> Shr<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Shr<Vr>,
UCUM<Vr, Ur>: Dimensionless,
[src]
impl<Vl, Ul, Vr, Ur> Shr<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: Shr<Vr>,
UCUM<Vr, Ur>: Dimensionless,
type Output = UCUM<<Vl as Shr<Vr>>::Output, Ul>
The resulting type after applying the >>
operator.
fn shr(self, rhs: UCUM<Vr, Ur>) -> Self::Output
[src]
fn shr(self, rhs: UCUM<Vr, Ur>) -> Self::Output
Performs the >>
operation.
impl<Vl, Ul, Vr, Ur> ShrAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: ShrAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
[src]
impl<Vl, Ul, Vr, Ur> ShrAssign<UCUM<Vr, Ur>> for UCUM<Vl, Ul> where
Vl: ShrAssign<Vr>,
UCUM<Vr, Ur>: Dimensionless,
fn shr_assign(&mut self, rhs: UCUM<Vr, Ur>)
[src]
fn shr_assign(&mut self, rhs: UCUM<Vr, Ur>)
Performs the >>=
operation.
impl<V, U> Add<f32> for UCUM<V, U> where
V: Add<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<f32> for UCUM<V, U> where
V: Add<f32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<f32>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: f32) -> Self::Output
[src]
fn add(self, rhs: f32) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for f32 where
f32: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for f32 where
f32: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f32 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<f32> for UCUM<V, U> where
V: AddAssign<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<f32> for UCUM<V, U> where
V: AddAssign<f32>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: f32)
[src]
fn add_assign(&mut self, rhs: f32)
Performs the +=
operation.
impl<V, U> Sub<f32> for UCUM<V, U> where
V: Sub<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<f32> for UCUM<V, U> where
V: Sub<f32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<f32>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: f32) -> Self::Output
[src]
fn sub(self, rhs: f32) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for f32 where
f32: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for f32 where
f32: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f32 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<f32> for UCUM<V, U> where
V: SubAssign<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<f32> for UCUM<V, U> where
V: SubAssign<f32>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: f32)
[src]
fn sub_assign(&mut self, rhs: f32)
Performs the -=
operation.
impl<V, U> BitAnd<f32> for UCUM<V, U> where
V: BitAnd<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<f32> for UCUM<V, U> where
V: BitAnd<f32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<f32>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: f32) -> Self::Output
[src]
fn bitand(self, rhs: f32) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for f32 where
f32: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for f32 where
f32: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f32 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<f32> for UCUM<V, U> where
V: BitAndAssign<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<f32> for UCUM<V, U> where
V: BitAndAssign<f32>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: f32)
[src]
fn bitand_assign(&mut self, rhs: f32)
Performs the &=
operation.
impl<V, U> BitOr<f32> for UCUM<V, U> where
V: BitOr<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<f32> for UCUM<V, U> where
V: BitOr<f32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<f32>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: f32) -> Self::Output
[src]
fn bitor(self, rhs: f32) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for f32 where
f32: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for f32 where
f32: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f32 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<f32> for UCUM<V, U> where
V: BitOrAssign<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<f32> for UCUM<V, U> where
V: BitOrAssign<f32>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: f32)
[src]
fn bitor_assign(&mut self, rhs: f32)
Performs the |=
operation.
impl<V, U> BitXor<f32> for UCUM<V, U> where
V: BitXor<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<f32> for UCUM<V, U> where
V: BitXor<f32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<f32>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: f32) -> Self::Output
[src]
fn bitxor(self, rhs: f32) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for f32 where
f32: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for f32 where
f32: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f32 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<f32> for UCUM<V, U> where
V: BitXorAssign<f32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<f32> for UCUM<V, U> where
V: BitXorAssign<f32>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: f32)
[src]
fn bitxor_assign(&mut self, rhs: f32)
Performs the ^=
operation.
impl<V, U> Mul<f32> for UCUM<V, U> where
V: Mul<f32>,
[src]
impl<V, U> Mul<f32> for UCUM<V, U> where
V: Mul<f32>,
type Output = UCUM<<V as Mul<f32>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: f32) -> Self::Output
[src]
fn mul(self, rhs: f32) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<f32> for UCUM<V, U> where
V: MulAssign<f32>,
[src]
impl<V, U> MulAssign<f32> for UCUM<V, U> where
V: MulAssign<f32>,
fn mul_assign(&mut self, rhs: f32)
[src]
fn mul_assign(&mut self, rhs: f32)
Performs the *=
operation.
impl<V, U> Div<f32> for UCUM<V, U> where
V: Div<f32>,
[src]
impl<V, U> Div<f32> for UCUM<V, U> where
V: Div<f32>,
type Output = UCUM<<V as Div<f32>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: f32) -> Self::Output
[src]
fn div(self, rhs: f32) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<f32> for UCUM<V, U> where
V: DivAssign<f32>,
[src]
impl<V, U> DivAssign<f32> for UCUM<V, U> where
V: DivAssign<f32>,
fn div_assign(&mut self, rhs: f32)
[src]
fn div_assign(&mut self, rhs: f32)
Performs the /=
operation.
impl<V, U> Rem<f32> for UCUM<V, U> where
V: Rem<f32>,
[src]
impl<V, U> Rem<f32> for UCUM<V, U> where
V: Rem<f32>,
type Output = UCUM<<V as Rem<f32>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: f32) -> Self::Output
[src]
fn rem(self, rhs: f32) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<f32> for UCUM<V, U> where
V: RemAssign<f32>,
[src]
impl<V, U> RemAssign<f32> for UCUM<V, U> where
V: RemAssign<f32>,
fn rem_assign(&mut self, rhs: f32)
[src]
fn rem_assign(&mut self, rhs: f32)
Performs the %=
operation.
impl<V, U> Shl<f32> for UCUM<V, U> where
V: Shl<f32>,
[src]
impl<V, U> Shl<f32> for UCUM<V, U> where
V: Shl<f32>,
type Output = UCUM<<V as Shl<f32>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: f32) -> Self::Output
[src]
fn shl(self, rhs: f32) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<f32> for UCUM<V, U> where
V: ShlAssign<f32>,
[src]
impl<V, U> ShlAssign<f32> for UCUM<V, U> where
V: ShlAssign<f32>,
fn shl_assign(&mut self, rhs: f32)
[src]
fn shl_assign(&mut self, rhs: f32)
Performs the <<=
operation.
impl<V, U> Shr<f32> for UCUM<V, U> where
V: Shr<f32>,
[src]
impl<V, U> Shr<f32> for UCUM<V, U> where
V: Shr<f32>,
type Output = UCUM<<V as Shr<f32>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: f32) -> Self::Output
[src]
fn shr(self, rhs: f32) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<f32> for UCUM<V, U> where
V: ShrAssign<f32>,
[src]
impl<V, U> ShrAssign<f32> for UCUM<V, U> where
V: ShrAssign<f32>,
fn shr_assign(&mut self, rhs: f32)
[src]
fn shr_assign(&mut self, rhs: f32)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for f32 where
f32: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for f32 where
f32: Mul<V>,
type Output = UCUM<Prod<f32, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for f32 where
f32: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for f32 where
f32: Div<V>,
U: Neg,
type Output = UCUM<Quot<f32, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for f32 where
f32: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for f32 where
f32: Rem<V>,
type Output = Unitless<<f32 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<f64> for UCUM<V, U> where
V: Add<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<f64> for UCUM<V, U> where
V: Add<f64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<f64>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: f64) -> Self::Output
[src]
fn add(self, rhs: f64) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for f64 where
f64: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for f64 where
f64: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f64 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<f64> for UCUM<V, U> where
V: AddAssign<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<f64> for UCUM<V, U> where
V: AddAssign<f64>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: f64)
[src]
fn add_assign(&mut self, rhs: f64)
Performs the +=
operation.
impl<V, U> Sub<f64> for UCUM<V, U> where
V: Sub<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<f64> for UCUM<V, U> where
V: Sub<f64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<f64>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: f64) -> Self::Output
[src]
fn sub(self, rhs: f64) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for f64 where
f64: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for f64 where
f64: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f64 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<f64> for UCUM<V, U> where
V: SubAssign<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<f64> for UCUM<V, U> where
V: SubAssign<f64>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: f64)
[src]
fn sub_assign(&mut self, rhs: f64)
Performs the -=
operation.
impl<V, U> BitAnd<f64> for UCUM<V, U> where
V: BitAnd<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<f64> for UCUM<V, U> where
V: BitAnd<f64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<f64>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: f64) -> Self::Output
[src]
fn bitand(self, rhs: f64) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for f64 where
f64: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for f64 where
f64: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f64 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<f64> for UCUM<V, U> where
V: BitAndAssign<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<f64> for UCUM<V, U> where
V: BitAndAssign<f64>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: f64)
[src]
fn bitand_assign(&mut self, rhs: f64)
Performs the &=
operation.
impl<V, U> BitOr<f64> for UCUM<V, U> where
V: BitOr<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<f64> for UCUM<V, U> where
V: BitOr<f64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<f64>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: f64) -> Self::Output
[src]
fn bitor(self, rhs: f64) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for f64 where
f64: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for f64 where
f64: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f64 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<f64> for UCUM<V, U> where
V: BitOrAssign<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<f64> for UCUM<V, U> where
V: BitOrAssign<f64>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: f64)
[src]
fn bitor_assign(&mut self, rhs: f64)
Performs the |=
operation.
impl<V, U> BitXor<f64> for UCUM<V, U> where
V: BitXor<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<f64> for UCUM<V, U> where
V: BitXor<f64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<f64>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: f64) -> Self::Output
[src]
fn bitxor(self, rhs: f64) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for f64 where
f64: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for f64 where
f64: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<f64 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<f64> for UCUM<V, U> where
V: BitXorAssign<f64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<f64> for UCUM<V, U> where
V: BitXorAssign<f64>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: f64)
[src]
fn bitxor_assign(&mut self, rhs: f64)
Performs the ^=
operation.
impl<V, U> Mul<f64> for UCUM<V, U> where
V: Mul<f64>,
[src]
impl<V, U> Mul<f64> for UCUM<V, U> where
V: Mul<f64>,
type Output = UCUM<<V as Mul<f64>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: f64) -> Self::Output
[src]
fn mul(self, rhs: f64) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<f64> for UCUM<V, U> where
V: MulAssign<f64>,
[src]
impl<V, U> MulAssign<f64> for UCUM<V, U> where
V: MulAssign<f64>,
fn mul_assign(&mut self, rhs: f64)
[src]
fn mul_assign(&mut self, rhs: f64)
Performs the *=
operation.
impl<V, U> Div<f64> for UCUM<V, U> where
V: Div<f64>,
[src]
impl<V, U> Div<f64> for UCUM<V, U> where
V: Div<f64>,
type Output = UCUM<<V as Div<f64>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: f64) -> Self::Output
[src]
fn div(self, rhs: f64) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<f64> for UCUM<V, U> where
V: DivAssign<f64>,
[src]
impl<V, U> DivAssign<f64> for UCUM<V, U> where
V: DivAssign<f64>,
fn div_assign(&mut self, rhs: f64)
[src]
fn div_assign(&mut self, rhs: f64)
Performs the /=
operation.
impl<V, U> Rem<f64> for UCUM<V, U> where
V: Rem<f64>,
[src]
impl<V, U> Rem<f64> for UCUM<V, U> where
V: Rem<f64>,
type Output = UCUM<<V as Rem<f64>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: f64) -> Self::Output
[src]
fn rem(self, rhs: f64) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<f64> for UCUM<V, U> where
V: RemAssign<f64>,
[src]
impl<V, U> RemAssign<f64> for UCUM<V, U> where
V: RemAssign<f64>,
fn rem_assign(&mut self, rhs: f64)
[src]
fn rem_assign(&mut self, rhs: f64)
Performs the %=
operation.
impl<V, U> Shl<f64> for UCUM<V, U> where
V: Shl<f64>,
[src]
impl<V, U> Shl<f64> for UCUM<V, U> where
V: Shl<f64>,
type Output = UCUM<<V as Shl<f64>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: f64) -> Self::Output
[src]
fn shl(self, rhs: f64) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<f64> for UCUM<V, U> where
V: ShlAssign<f64>,
[src]
impl<V, U> ShlAssign<f64> for UCUM<V, U> where
V: ShlAssign<f64>,
fn shl_assign(&mut self, rhs: f64)
[src]
fn shl_assign(&mut self, rhs: f64)
Performs the <<=
operation.
impl<V, U> Shr<f64> for UCUM<V, U> where
V: Shr<f64>,
[src]
impl<V, U> Shr<f64> for UCUM<V, U> where
V: Shr<f64>,
type Output = UCUM<<V as Shr<f64>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: f64) -> Self::Output
[src]
fn shr(self, rhs: f64) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<f64> for UCUM<V, U> where
V: ShrAssign<f64>,
[src]
impl<V, U> ShrAssign<f64> for UCUM<V, U> where
V: ShrAssign<f64>,
fn shr_assign(&mut self, rhs: f64)
[src]
fn shr_assign(&mut self, rhs: f64)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for f64 where
f64: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for f64 where
f64: Mul<V>,
type Output = UCUM<Prod<f64, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for f64 where
f64: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for f64 where
f64: Div<V>,
U: Neg,
type Output = UCUM<Quot<f64, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for f64 where
f64: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for f64 where
f64: Rem<V>,
type Output = Unitless<<f64 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<i8> for UCUM<V, U> where
V: Add<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<i8> for UCUM<V, U> where
V: Add<i8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<i8>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: i8) -> Self::Output
[src]
fn add(self, rhs: i8) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for i8 where
i8: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for i8 where
i8: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i8 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<i8> for UCUM<V, U> where
V: AddAssign<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<i8> for UCUM<V, U> where
V: AddAssign<i8>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: i8)
[src]
fn add_assign(&mut self, rhs: i8)
Performs the +=
operation.
impl<V, U> Sub<i8> for UCUM<V, U> where
V: Sub<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<i8> for UCUM<V, U> where
V: Sub<i8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<i8>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: i8) -> Self::Output
[src]
fn sub(self, rhs: i8) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for i8 where
i8: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for i8 where
i8: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i8 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<i8> for UCUM<V, U> where
V: SubAssign<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<i8> for UCUM<V, U> where
V: SubAssign<i8>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: i8)
[src]
fn sub_assign(&mut self, rhs: i8)
Performs the -=
operation.
impl<V, U> BitAnd<i8> for UCUM<V, U> where
V: BitAnd<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<i8> for UCUM<V, U> where
V: BitAnd<i8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<i8>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: i8) -> Self::Output
[src]
fn bitand(self, rhs: i8) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for i8 where
i8: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for i8 where
i8: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i8 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<i8> for UCUM<V, U> where
V: BitAndAssign<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<i8> for UCUM<V, U> where
V: BitAndAssign<i8>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: i8)
[src]
fn bitand_assign(&mut self, rhs: i8)
Performs the &=
operation.
impl<V, U> BitOr<i8> for UCUM<V, U> where
V: BitOr<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<i8> for UCUM<V, U> where
V: BitOr<i8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<i8>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: i8) -> Self::Output
[src]
fn bitor(self, rhs: i8) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for i8 where
i8: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for i8 where
i8: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i8 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<i8> for UCUM<V, U> where
V: BitOrAssign<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<i8> for UCUM<V, U> where
V: BitOrAssign<i8>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: i8)
[src]
fn bitor_assign(&mut self, rhs: i8)
Performs the |=
operation.
impl<V, U> BitXor<i8> for UCUM<V, U> where
V: BitXor<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<i8> for UCUM<V, U> where
V: BitXor<i8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<i8>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i8) -> Self::Output
[src]
fn bitxor(self, rhs: i8) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for i8 where
i8: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for i8 where
i8: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i8 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<i8> for UCUM<V, U> where
V: BitXorAssign<i8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<i8> for UCUM<V, U> where
V: BitXorAssign<i8>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: i8)
[src]
fn bitxor_assign(&mut self, rhs: i8)
Performs the ^=
operation.
impl<V, U> Mul<i8> for UCUM<V, U> where
V: Mul<i8>,
[src]
impl<V, U> Mul<i8> for UCUM<V, U> where
V: Mul<i8>,
type Output = UCUM<<V as Mul<i8>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: i8) -> Self::Output
[src]
fn mul(self, rhs: i8) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<i8> for UCUM<V, U> where
V: MulAssign<i8>,
[src]
impl<V, U> MulAssign<i8> for UCUM<V, U> where
V: MulAssign<i8>,
fn mul_assign(&mut self, rhs: i8)
[src]
fn mul_assign(&mut self, rhs: i8)
Performs the *=
operation.
impl<V, U> Div<i8> for UCUM<V, U> where
V: Div<i8>,
[src]
impl<V, U> Div<i8> for UCUM<V, U> where
V: Div<i8>,
type Output = UCUM<<V as Div<i8>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: i8) -> Self::Output
[src]
fn div(self, rhs: i8) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<i8> for UCUM<V, U> where
V: DivAssign<i8>,
[src]
impl<V, U> DivAssign<i8> for UCUM<V, U> where
V: DivAssign<i8>,
fn div_assign(&mut self, rhs: i8)
[src]
fn div_assign(&mut self, rhs: i8)
Performs the /=
operation.
impl<V, U> Rem<i8> for UCUM<V, U> where
V: Rem<i8>,
[src]
impl<V, U> Rem<i8> for UCUM<V, U> where
V: Rem<i8>,
type Output = UCUM<<V as Rem<i8>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: i8) -> Self::Output
[src]
fn rem(self, rhs: i8) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<i8> for UCUM<V, U> where
V: RemAssign<i8>,
[src]
impl<V, U> RemAssign<i8> for UCUM<V, U> where
V: RemAssign<i8>,
fn rem_assign(&mut self, rhs: i8)
[src]
fn rem_assign(&mut self, rhs: i8)
Performs the %=
operation.
impl<V, U> Shl<i8> for UCUM<V, U> where
V: Shl<i8>,
[src]
impl<V, U> Shl<i8> for UCUM<V, U> where
V: Shl<i8>,
type Output = UCUM<<V as Shl<i8>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i8) -> Self::Output
[src]
fn shl(self, rhs: i8) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<i8> for UCUM<V, U> where
V: ShlAssign<i8>,
[src]
impl<V, U> ShlAssign<i8> for UCUM<V, U> where
V: ShlAssign<i8>,
fn shl_assign(&mut self, rhs: i8)
[src]
fn shl_assign(&mut self, rhs: i8)
Performs the <<=
operation.
impl<V, U> Shr<i8> for UCUM<V, U> where
V: Shr<i8>,
[src]
impl<V, U> Shr<i8> for UCUM<V, U> where
V: Shr<i8>,
type Output = UCUM<<V as Shr<i8>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i8) -> Self::Output
[src]
fn shr(self, rhs: i8) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<i8> for UCUM<V, U> where
V: ShrAssign<i8>,
[src]
impl<V, U> ShrAssign<i8> for UCUM<V, U> where
V: ShrAssign<i8>,
fn shr_assign(&mut self, rhs: i8)
[src]
fn shr_assign(&mut self, rhs: i8)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for i8 where
i8: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for i8 where
i8: Mul<V>,
type Output = UCUM<Prod<i8, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for i8 where
i8: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for i8 where
i8: Div<V>,
U: Neg,
type Output = UCUM<Quot<i8, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for i8 where
i8: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for i8 where
i8: Rem<V>,
type Output = Unitless<<i8 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<i16> for UCUM<V, U> where
V: Add<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<i16> for UCUM<V, U> where
V: Add<i16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<i16>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: i16) -> Self::Output
[src]
fn add(self, rhs: i16) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for i16 where
i16: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for i16 where
i16: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i16 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<i16> for UCUM<V, U> where
V: AddAssign<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<i16> for UCUM<V, U> where
V: AddAssign<i16>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: i16)
[src]
fn add_assign(&mut self, rhs: i16)
Performs the +=
operation.
impl<V, U> Sub<i16> for UCUM<V, U> where
V: Sub<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<i16> for UCUM<V, U> where
V: Sub<i16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<i16>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: i16) -> Self::Output
[src]
fn sub(self, rhs: i16) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for i16 where
i16: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for i16 where
i16: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i16 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<i16> for UCUM<V, U> where
V: SubAssign<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<i16> for UCUM<V, U> where
V: SubAssign<i16>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: i16)
[src]
fn sub_assign(&mut self, rhs: i16)
Performs the -=
operation.
impl<V, U> BitAnd<i16> for UCUM<V, U> where
V: BitAnd<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<i16> for UCUM<V, U> where
V: BitAnd<i16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<i16>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: i16) -> Self::Output
[src]
fn bitand(self, rhs: i16) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for i16 where
i16: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for i16 where
i16: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i16 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<i16> for UCUM<V, U> where
V: BitAndAssign<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<i16> for UCUM<V, U> where
V: BitAndAssign<i16>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: i16)
[src]
fn bitand_assign(&mut self, rhs: i16)
Performs the &=
operation.
impl<V, U> BitOr<i16> for UCUM<V, U> where
V: BitOr<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<i16> for UCUM<V, U> where
V: BitOr<i16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<i16>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: i16) -> Self::Output
[src]
fn bitor(self, rhs: i16) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for i16 where
i16: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for i16 where
i16: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i16 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<i16> for UCUM<V, U> where
V: BitOrAssign<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<i16> for UCUM<V, U> where
V: BitOrAssign<i16>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: i16)
[src]
fn bitor_assign(&mut self, rhs: i16)
Performs the |=
operation.
impl<V, U> BitXor<i16> for UCUM<V, U> where
V: BitXor<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<i16> for UCUM<V, U> where
V: BitXor<i16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<i16>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i16) -> Self::Output
[src]
fn bitxor(self, rhs: i16) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for i16 where
i16: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for i16 where
i16: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i16 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<i16> for UCUM<V, U> where
V: BitXorAssign<i16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<i16> for UCUM<V, U> where
V: BitXorAssign<i16>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: i16)
[src]
fn bitxor_assign(&mut self, rhs: i16)
Performs the ^=
operation.
impl<V, U> Mul<i16> for UCUM<V, U> where
V: Mul<i16>,
[src]
impl<V, U> Mul<i16> for UCUM<V, U> where
V: Mul<i16>,
type Output = UCUM<<V as Mul<i16>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: i16) -> Self::Output
[src]
fn mul(self, rhs: i16) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<i16> for UCUM<V, U> where
V: MulAssign<i16>,
[src]
impl<V, U> MulAssign<i16> for UCUM<V, U> where
V: MulAssign<i16>,
fn mul_assign(&mut self, rhs: i16)
[src]
fn mul_assign(&mut self, rhs: i16)
Performs the *=
operation.
impl<V, U> Div<i16> for UCUM<V, U> where
V: Div<i16>,
[src]
impl<V, U> Div<i16> for UCUM<V, U> where
V: Div<i16>,
type Output = UCUM<<V as Div<i16>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: i16) -> Self::Output
[src]
fn div(self, rhs: i16) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<i16> for UCUM<V, U> where
V: DivAssign<i16>,
[src]
impl<V, U> DivAssign<i16> for UCUM<V, U> where
V: DivAssign<i16>,
fn div_assign(&mut self, rhs: i16)
[src]
fn div_assign(&mut self, rhs: i16)
Performs the /=
operation.
impl<V, U> Rem<i16> for UCUM<V, U> where
V: Rem<i16>,
[src]
impl<V, U> Rem<i16> for UCUM<V, U> where
V: Rem<i16>,
type Output = UCUM<<V as Rem<i16>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: i16) -> Self::Output
[src]
fn rem(self, rhs: i16) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<i16> for UCUM<V, U> where
V: RemAssign<i16>,
[src]
impl<V, U> RemAssign<i16> for UCUM<V, U> where
V: RemAssign<i16>,
fn rem_assign(&mut self, rhs: i16)
[src]
fn rem_assign(&mut self, rhs: i16)
Performs the %=
operation.
impl<V, U> Shl<i16> for UCUM<V, U> where
V: Shl<i16>,
[src]
impl<V, U> Shl<i16> for UCUM<V, U> where
V: Shl<i16>,
type Output = UCUM<<V as Shl<i16>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i16) -> Self::Output
[src]
fn shl(self, rhs: i16) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<i16> for UCUM<V, U> where
V: ShlAssign<i16>,
[src]
impl<V, U> ShlAssign<i16> for UCUM<V, U> where
V: ShlAssign<i16>,
fn shl_assign(&mut self, rhs: i16)
[src]
fn shl_assign(&mut self, rhs: i16)
Performs the <<=
operation.
impl<V, U> Shr<i16> for UCUM<V, U> where
V: Shr<i16>,
[src]
impl<V, U> Shr<i16> for UCUM<V, U> where
V: Shr<i16>,
type Output = UCUM<<V as Shr<i16>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i16) -> Self::Output
[src]
fn shr(self, rhs: i16) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<i16> for UCUM<V, U> where
V: ShrAssign<i16>,
[src]
impl<V, U> ShrAssign<i16> for UCUM<V, U> where
V: ShrAssign<i16>,
fn shr_assign(&mut self, rhs: i16)
[src]
fn shr_assign(&mut self, rhs: i16)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for i16 where
i16: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for i16 where
i16: Mul<V>,
type Output = UCUM<Prod<i16, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for i16 where
i16: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for i16 where
i16: Div<V>,
U: Neg,
type Output = UCUM<Quot<i16, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for i16 where
i16: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for i16 where
i16: Rem<V>,
type Output = Unitless<<i16 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<i32> for UCUM<V, U> where
V: Add<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<i32> for UCUM<V, U> where
V: Add<i32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<i32>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> Self::Output
[src]
fn add(self, rhs: i32) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for i32 where
i32: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for i32 where
i32: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i32 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<i32> for UCUM<V, U> where
V: AddAssign<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<i32> for UCUM<V, U> where
V: AddAssign<i32>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: i32)
[src]
fn add_assign(&mut self, rhs: i32)
Performs the +=
operation.
impl<V, U> Sub<i32> for UCUM<V, U> where
V: Sub<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<i32> for UCUM<V, U> where
V: Sub<i32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<i32>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> Self::Output
[src]
fn sub(self, rhs: i32) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for i32 where
i32: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for i32 where
i32: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i32 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<i32> for UCUM<V, U> where
V: SubAssign<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<i32> for UCUM<V, U> where
V: SubAssign<i32>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: i32)
[src]
fn sub_assign(&mut self, rhs: i32)
Performs the -=
operation.
impl<V, U> BitAnd<i32> for UCUM<V, U> where
V: BitAnd<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<i32> for UCUM<V, U> where
V: BitAnd<i32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<i32>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: i32) -> Self::Output
[src]
fn bitand(self, rhs: i32) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for i32 where
i32: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for i32 where
i32: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i32 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<i32> for UCUM<V, U> where
V: BitAndAssign<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<i32> for UCUM<V, U> where
V: BitAndAssign<i32>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: i32)
[src]
fn bitand_assign(&mut self, rhs: i32)
Performs the &=
operation.
impl<V, U> BitOr<i32> for UCUM<V, U> where
V: BitOr<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<i32> for UCUM<V, U> where
V: BitOr<i32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<i32>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: i32) -> Self::Output
[src]
fn bitor(self, rhs: i32) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for i32 where
i32: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for i32 where
i32: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i32 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<i32> for UCUM<V, U> where
V: BitOrAssign<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<i32> for UCUM<V, U> where
V: BitOrAssign<i32>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: i32)
[src]
fn bitor_assign(&mut self, rhs: i32)
Performs the |=
operation.
impl<V, U> BitXor<i32> for UCUM<V, U> where
V: BitXor<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<i32> for UCUM<V, U> where
V: BitXor<i32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<i32>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i32) -> Self::Output
[src]
fn bitxor(self, rhs: i32) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for i32 where
i32: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for i32 where
i32: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i32 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<i32> for UCUM<V, U> where
V: BitXorAssign<i32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<i32> for UCUM<V, U> where
V: BitXorAssign<i32>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: i32)
[src]
fn bitxor_assign(&mut self, rhs: i32)
Performs the ^=
operation.
impl<V, U> Mul<i32> for UCUM<V, U> where
V: Mul<i32>,
[src]
impl<V, U> Mul<i32> for UCUM<V, U> where
V: Mul<i32>,
type Output = UCUM<<V as Mul<i32>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> Self::Output
[src]
fn mul(self, rhs: i32) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<i32> for UCUM<V, U> where
V: MulAssign<i32>,
[src]
impl<V, U> MulAssign<i32> for UCUM<V, U> where
V: MulAssign<i32>,
fn mul_assign(&mut self, rhs: i32)
[src]
fn mul_assign(&mut self, rhs: i32)
Performs the *=
operation.
impl<V, U> Div<i32> for UCUM<V, U> where
V: Div<i32>,
[src]
impl<V, U> Div<i32> for UCUM<V, U> where
V: Div<i32>,
type Output = UCUM<<V as Div<i32>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> Self::Output
[src]
fn div(self, rhs: i32) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<i32> for UCUM<V, U> where
V: DivAssign<i32>,
[src]
impl<V, U> DivAssign<i32> for UCUM<V, U> where
V: DivAssign<i32>,
fn div_assign(&mut self, rhs: i32)
[src]
fn div_assign(&mut self, rhs: i32)
Performs the /=
operation.
impl<V, U> Rem<i32> for UCUM<V, U> where
V: Rem<i32>,
[src]
impl<V, U> Rem<i32> for UCUM<V, U> where
V: Rem<i32>,
type Output = UCUM<<V as Rem<i32>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: i32) -> Self::Output
[src]
fn rem(self, rhs: i32) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<i32> for UCUM<V, U> where
V: RemAssign<i32>,
[src]
impl<V, U> RemAssign<i32> for UCUM<V, U> where
V: RemAssign<i32>,
fn rem_assign(&mut self, rhs: i32)
[src]
fn rem_assign(&mut self, rhs: i32)
Performs the %=
operation.
impl<V, U> Shl<i32> for UCUM<V, U> where
V: Shl<i32>,
[src]
impl<V, U> Shl<i32> for UCUM<V, U> where
V: Shl<i32>,
type Output = UCUM<<V as Shl<i32>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> Self::Output
[src]
fn shl(self, rhs: i32) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<i32> for UCUM<V, U> where
V: ShlAssign<i32>,
[src]
impl<V, U> ShlAssign<i32> for UCUM<V, U> where
V: ShlAssign<i32>,
fn shl_assign(&mut self, rhs: i32)
[src]
fn shl_assign(&mut self, rhs: i32)
Performs the <<=
operation.
impl<V, U> Shr<i32> for UCUM<V, U> where
V: Shr<i32>,
[src]
impl<V, U> Shr<i32> for UCUM<V, U> where
V: Shr<i32>,
type Output = UCUM<<V as Shr<i32>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> Self::Output
[src]
fn shr(self, rhs: i32) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<i32> for UCUM<V, U> where
V: ShrAssign<i32>,
[src]
impl<V, U> ShrAssign<i32> for UCUM<V, U> where
V: ShrAssign<i32>,
fn shr_assign(&mut self, rhs: i32)
[src]
fn shr_assign(&mut self, rhs: i32)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for i32 where
i32: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for i32 where
i32: Mul<V>,
type Output = UCUM<Prod<i32, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for i32 where
i32: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for i32 where
i32: Div<V>,
U: Neg,
type Output = UCUM<Quot<i32, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for i32 where
i32: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for i32 where
i32: Rem<V>,
type Output = Unitless<<i32 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<i64> for UCUM<V, U> where
V: Add<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<i64> for UCUM<V, U> where
V: Add<i64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<i64>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: i64) -> Self::Output
[src]
fn add(self, rhs: i64) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for i64 where
i64: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for i64 where
i64: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i64 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<i64> for UCUM<V, U> where
V: AddAssign<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<i64> for UCUM<V, U> where
V: AddAssign<i64>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: i64)
[src]
fn add_assign(&mut self, rhs: i64)
Performs the +=
operation.
impl<V, U> Sub<i64> for UCUM<V, U> where
V: Sub<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<i64> for UCUM<V, U> where
V: Sub<i64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<i64>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: i64) -> Self::Output
[src]
fn sub(self, rhs: i64) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for i64 where
i64: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for i64 where
i64: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i64 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<i64> for UCUM<V, U> where
V: SubAssign<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<i64> for UCUM<V, U> where
V: SubAssign<i64>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: i64)
[src]
fn sub_assign(&mut self, rhs: i64)
Performs the -=
operation.
impl<V, U> BitAnd<i64> for UCUM<V, U> where
V: BitAnd<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<i64> for UCUM<V, U> where
V: BitAnd<i64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<i64>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: i64) -> Self::Output
[src]
fn bitand(self, rhs: i64) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for i64 where
i64: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for i64 where
i64: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i64 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<i64> for UCUM<V, U> where
V: BitAndAssign<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<i64> for UCUM<V, U> where
V: BitAndAssign<i64>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: i64)
[src]
fn bitand_assign(&mut self, rhs: i64)
Performs the &=
operation.
impl<V, U> BitOr<i64> for UCUM<V, U> where
V: BitOr<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<i64> for UCUM<V, U> where
V: BitOr<i64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<i64>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: i64) -> Self::Output
[src]
fn bitor(self, rhs: i64) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for i64 where
i64: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for i64 where
i64: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i64 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<i64> for UCUM<V, U> where
V: BitOrAssign<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<i64> for UCUM<V, U> where
V: BitOrAssign<i64>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: i64)
[src]
fn bitor_assign(&mut self, rhs: i64)
Performs the |=
operation.
impl<V, U> BitXor<i64> for UCUM<V, U> where
V: BitXor<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<i64> for UCUM<V, U> where
V: BitXor<i64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<i64>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i64) -> Self::Output
[src]
fn bitxor(self, rhs: i64) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for i64 where
i64: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for i64 where
i64: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<i64 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<i64> for UCUM<V, U> where
V: BitXorAssign<i64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<i64> for UCUM<V, U> where
V: BitXorAssign<i64>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: i64)
[src]
fn bitxor_assign(&mut self, rhs: i64)
Performs the ^=
operation.
impl<V, U> Mul<i64> for UCUM<V, U> where
V: Mul<i64>,
[src]
impl<V, U> Mul<i64> for UCUM<V, U> where
V: Mul<i64>,
type Output = UCUM<<V as Mul<i64>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: i64) -> Self::Output
[src]
fn mul(self, rhs: i64) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<i64> for UCUM<V, U> where
V: MulAssign<i64>,
[src]
impl<V, U> MulAssign<i64> for UCUM<V, U> where
V: MulAssign<i64>,
fn mul_assign(&mut self, rhs: i64)
[src]
fn mul_assign(&mut self, rhs: i64)
Performs the *=
operation.
impl<V, U> Div<i64> for UCUM<V, U> where
V: Div<i64>,
[src]
impl<V, U> Div<i64> for UCUM<V, U> where
V: Div<i64>,
type Output = UCUM<<V as Div<i64>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: i64) -> Self::Output
[src]
fn div(self, rhs: i64) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<i64> for UCUM<V, U> where
V: DivAssign<i64>,
[src]
impl<V, U> DivAssign<i64> for UCUM<V, U> where
V: DivAssign<i64>,
fn div_assign(&mut self, rhs: i64)
[src]
fn div_assign(&mut self, rhs: i64)
Performs the /=
operation.
impl<V, U> Rem<i64> for UCUM<V, U> where
V: Rem<i64>,
[src]
impl<V, U> Rem<i64> for UCUM<V, U> where
V: Rem<i64>,
type Output = UCUM<<V as Rem<i64>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: i64) -> Self::Output
[src]
fn rem(self, rhs: i64) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<i64> for UCUM<V, U> where
V: RemAssign<i64>,
[src]
impl<V, U> RemAssign<i64> for UCUM<V, U> where
V: RemAssign<i64>,
fn rem_assign(&mut self, rhs: i64)
[src]
fn rem_assign(&mut self, rhs: i64)
Performs the %=
operation.
impl<V, U> Shl<i64> for UCUM<V, U> where
V: Shl<i64>,
[src]
impl<V, U> Shl<i64> for UCUM<V, U> where
V: Shl<i64>,
type Output = UCUM<<V as Shl<i64>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i64) -> Self::Output
[src]
fn shl(self, rhs: i64) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<i64> for UCUM<V, U> where
V: ShlAssign<i64>,
[src]
impl<V, U> ShlAssign<i64> for UCUM<V, U> where
V: ShlAssign<i64>,
fn shl_assign(&mut self, rhs: i64)
[src]
fn shl_assign(&mut self, rhs: i64)
Performs the <<=
operation.
impl<V, U> Shr<i64> for UCUM<V, U> where
V: Shr<i64>,
[src]
impl<V, U> Shr<i64> for UCUM<V, U> where
V: Shr<i64>,
type Output = UCUM<<V as Shr<i64>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i64) -> Self::Output
[src]
fn shr(self, rhs: i64) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<i64> for UCUM<V, U> where
V: ShrAssign<i64>,
[src]
impl<V, U> ShrAssign<i64> for UCUM<V, U> where
V: ShrAssign<i64>,
fn shr_assign(&mut self, rhs: i64)
[src]
fn shr_assign(&mut self, rhs: i64)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for i64 where
i64: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for i64 where
i64: Mul<V>,
type Output = UCUM<Prod<i64, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for i64 where
i64: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for i64 where
i64: Div<V>,
U: Neg,
type Output = UCUM<Quot<i64, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for i64 where
i64: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for i64 where
i64: Rem<V>,
type Output = Unitless<<i64 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<isize> for UCUM<V, U> where
V: Add<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<isize> for UCUM<V, U> where
V: Add<isize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<isize>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: isize) -> Self::Output
[src]
fn add(self, rhs: isize) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for isize where
isize: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for isize where
isize: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<isize as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<isize> for UCUM<V, U> where
V: AddAssign<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<isize> for UCUM<V, U> where
V: AddAssign<isize>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: isize)
[src]
fn add_assign(&mut self, rhs: isize)
Performs the +=
operation.
impl<V, U> Sub<isize> for UCUM<V, U> where
V: Sub<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<isize> for UCUM<V, U> where
V: Sub<isize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<isize>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: isize) -> Self::Output
[src]
fn sub(self, rhs: isize) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for isize where
isize: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for isize where
isize: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<isize as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<isize> for UCUM<V, U> where
V: SubAssign<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<isize> for UCUM<V, U> where
V: SubAssign<isize>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: isize)
[src]
fn sub_assign(&mut self, rhs: isize)
Performs the -=
operation.
impl<V, U> BitAnd<isize> for UCUM<V, U> where
V: BitAnd<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<isize> for UCUM<V, U> where
V: BitAnd<isize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<isize>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: isize) -> Self::Output
[src]
fn bitand(self, rhs: isize) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for isize where
isize: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for isize where
isize: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<isize as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<isize> for UCUM<V, U> where
V: BitAndAssign<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<isize> for UCUM<V, U> where
V: BitAndAssign<isize>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: isize)
[src]
fn bitand_assign(&mut self, rhs: isize)
Performs the &=
operation.
impl<V, U> BitOr<isize> for UCUM<V, U> where
V: BitOr<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<isize> for UCUM<V, U> where
V: BitOr<isize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<isize>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: isize) -> Self::Output
[src]
fn bitor(self, rhs: isize) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for isize where
isize: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for isize where
isize: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<isize as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<isize> for UCUM<V, U> where
V: BitOrAssign<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<isize> for UCUM<V, U> where
V: BitOrAssign<isize>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: isize)
[src]
fn bitor_assign(&mut self, rhs: isize)
Performs the |=
operation.
impl<V, U> BitXor<isize> for UCUM<V, U> where
V: BitXor<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<isize> for UCUM<V, U> where
V: BitXor<isize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<isize>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: isize) -> Self::Output
[src]
fn bitxor(self, rhs: isize) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for isize where
isize: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for isize where
isize: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<isize as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<isize> for UCUM<V, U> where
V: BitXorAssign<isize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<isize> for UCUM<V, U> where
V: BitXorAssign<isize>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: isize)
[src]
fn bitxor_assign(&mut self, rhs: isize)
Performs the ^=
operation.
impl<V, U> Mul<isize> for UCUM<V, U> where
V: Mul<isize>,
[src]
impl<V, U> Mul<isize> for UCUM<V, U> where
V: Mul<isize>,
type Output = UCUM<<V as Mul<isize>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: isize) -> Self::Output
[src]
fn mul(self, rhs: isize) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<isize> for UCUM<V, U> where
V: MulAssign<isize>,
[src]
impl<V, U> MulAssign<isize> for UCUM<V, U> where
V: MulAssign<isize>,
fn mul_assign(&mut self, rhs: isize)
[src]
fn mul_assign(&mut self, rhs: isize)
Performs the *=
operation.
impl<V, U> Div<isize> for UCUM<V, U> where
V: Div<isize>,
[src]
impl<V, U> Div<isize> for UCUM<V, U> where
V: Div<isize>,
type Output = UCUM<<V as Div<isize>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: isize) -> Self::Output
[src]
fn div(self, rhs: isize) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<isize> for UCUM<V, U> where
V: DivAssign<isize>,
[src]
impl<V, U> DivAssign<isize> for UCUM<V, U> where
V: DivAssign<isize>,
fn div_assign(&mut self, rhs: isize)
[src]
fn div_assign(&mut self, rhs: isize)
Performs the /=
operation.
impl<V, U> Rem<isize> for UCUM<V, U> where
V: Rem<isize>,
[src]
impl<V, U> Rem<isize> for UCUM<V, U> where
V: Rem<isize>,
type Output = UCUM<<V as Rem<isize>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: isize) -> Self::Output
[src]
fn rem(self, rhs: isize) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<isize> for UCUM<V, U> where
V: RemAssign<isize>,
[src]
impl<V, U> RemAssign<isize> for UCUM<V, U> where
V: RemAssign<isize>,
fn rem_assign(&mut self, rhs: isize)
[src]
fn rem_assign(&mut self, rhs: isize)
Performs the %=
operation.
impl<V, U> Shl<isize> for UCUM<V, U> where
V: Shl<isize>,
[src]
impl<V, U> Shl<isize> for UCUM<V, U> where
V: Shl<isize>,
type Output = UCUM<<V as Shl<isize>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: isize) -> Self::Output
[src]
fn shl(self, rhs: isize) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<isize> for UCUM<V, U> where
V: ShlAssign<isize>,
[src]
impl<V, U> ShlAssign<isize> for UCUM<V, U> where
V: ShlAssign<isize>,
fn shl_assign(&mut self, rhs: isize)
[src]
fn shl_assign(&mut self, rhs: isize)
Performs the <<=
operation.
impl<V, U> Shr<isize> for UCUM<V, U> where
V: Shr<isize>,
[src]
impl<V, U> Shr<isize> for UCUM<V, U> where
V: Shr<isize>,
type Output = UCUM<<V as Shr<isize>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: isize) -> Self::Output
[src]
fn shr(self, rhs: isize) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<isize> for UCUM<V, U> where
V: ShrAssign<isize>,
[src]
impl<V, U> ShrAssign<isize> for UCUM<V, U> where
V: ShrAssign<isize>,
fn shr_assign(&mut self, rhs: isize)
[src]
fn shr_assign(&mut self, rhs: isize)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for isize where
isize: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for isize where
isize: Mul<V>,
type Output = UCUM<Prod<isize, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for isize where
isize: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for isize where
isize: Div<V>,
U: Neg,
type Output = UCUM<Quot<isize, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for isize where
isize: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for isize where
isize: Rem<V>,
type Output = Unitless<<isize as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<u8> for UCUM<V, U> where
V: Add<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<u8> for UCUM<V, U> where
V: Add<u8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<u8>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: u8) -> Self::Output
[src]
fn add(self, rhs: u8) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for u8 where
u8: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for u8 where
u8: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u8 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<u8> for UCUM<V, U> where
V: AddAssign<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<u8> for UCUM<V, U> where
V: AddAssign<u8>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: u8)
[src]
fn add_assign(&mut self, rhs: u8)
Performs the +=
operation.
impl<V, U> Sub<u8> for UCUM<V, U> where
V: Sub<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<u8> for UCUM<V, U> where
V: Sub<u8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<u8>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: u8) -> Self::Output
[src]
fn sub(self, rhs: u8) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for u8 where
u8: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for u8 where
u8: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u8 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<u8> for UCUM<V, U> where
V: SubAssign<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<u8> for UCUM<V, U> where
V: SubAssign<u8>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: u8)
[src]
fn sub_assign(&mut self, rhs: u8)
Performs the -=
operation.
impl<V, U> BitAnd<u8> for UCUM<V, U> where
V: BitAnd<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<u8> for UCUM<V, U> where
V: BitAnd<u8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<u8>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: u8) -> Self::Output
[src]
fn bitand(self, rhs: u8) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for u8 where
u8: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for u8 where
u8: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u8 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<u8> for UCUM<V, U> where
V: BitAndAssign<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<u8> for UCUM<V, U> where
V: BitAndAssign<u8>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: u8)
[src]
fn bitand_assign(&mut self, rhs: u8)
Performs the &=
operation.
impl<V, U> BitOr<u8> for UCUM<V, U> where
V: BitOr<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<u8> for UCUM<V, U> where
V: BitOr<u8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<u8>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: u8) -> Self::Output
[src]
fn bitor(self, rhs: u8) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for u8 where
u8: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for u8 where
u8: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u8 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<u8> for UCUM<V, U> where
V: BitOrAssign<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<u8> for UCUM<V, U> where
V: BitOrAssign<u8>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: u8)
[src]
fn bitor_assign(&mut self, rhs: u8)
Performs the |=
operation.
impl<V, U> BitXor<u8> for UCUM<V, U> where
V: BitXor<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<u8> for UCUM<V, U> where
V: BitXor<u8>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<u8>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u8) -> Self::Output
[src]
fn bitxor(self, rhs: u8) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for u8 where
u8: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for u8 where
u8: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u8 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<u8> for UCUM<V, U> where
V: BitXorAssign<u8>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<u8> for UCUM<V, U> where
V: BitXorAssign<u8>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: u8)
[src]
fn bitxor_assign(&mut self, rhs: u8)
Performs the ^=
operation.
impl<V, U> Mul<u8> for UCUM<V, U> where
V: Mul<u8>,
[src]
impl<V, U> Mul<u8> for UCUM<V, U> where
V: Mul<u8>,
type Output = UCUM<<V as Mul<u8>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: u8) -> Self::Output
[src]
fn mul(self, rhs: u8) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<u8> for UCUM<V, U> where
V: MulAssign<u8>,
[src]
impl<V, U> MulAssign<u8> for UCUM<V, U> where
V: MulAssign<u8>,
fn mul_assign(&mut self, rhs: u8)
[src]
fn mul_assign(&mut self, rhs: u8)
Performs the *=
operation.
impl<V, U> Div<u8> for UCUM<V, U> where
V: Div<u8>,
[src]
impl<V, U> Div<u8> for UCUM<V, U> where
V: Div<u8>,
type Output = UCUM<<V as Div<u8>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: u8) -> Self::Output
[src]
fn div(self, rhs: u8) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<u8> for UCUM<V, U> where
V: DivAssign<u8>,
[src]
impl<V, U> DivAssign<u8> for UCUM<V, U> where
V: DivAssign<u8>,
fn div_assign(&mut self, rhs: u8)
[src]
fn div_assign(&mut self, rhs: u8)
Performs the /=
operation.
impl<V, U> Rem<u8> for UCUM<V, U> where
V: Rem<u8>,
[src]
impl<V, U> Rem<u8> for UCUM<V, U> where
V: Rem<u8>,
type Output = UCUM<<V as Rem<u8>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: u8) -> Self::Output
[src]
fn rem(self, rhs: u8) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<u8> for UCUM<V, U> where
V: RemAssign<u8>,
[src]
impl<V, U> RemAssign<u8> for UCUM<V, U> where
V: RemAssign<u8>,
fn rem_assign(&mut self, rhs: u8)
[src]
fn rem_assign(&mut self, rhs: u8)
Performs the %=
operation.
impl<V, U> Shl<u8> for UCUM<V, U> where
V: Shl<u8>,
[src]
impl<V, U> Shl<u8> for UCUM<V, U> where
V: Shl<u8>,
type Output = UCUM<<V as Shl<u8>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u8) -> Self::Output
[src]
fn shl(self, rhs: u8) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<u8> for UCUM<V, U> where
V: ShlAssign<u8>,
[src]
impl<V, U> ShlAssign<u8> for UCUM<V, U> where
V: ShlAssign<u8>,
fn shl_assign(&mut self, rhs: u8)
[src]
fn shl_assign(&mut self, rhs: u8)
Performs the <<=
operation.
impl<V, U> Shr<u8> for UCUM<V, U> where
V: Shr<u8>,
[src]
impl<V, U> Shr<u8> for UCUM<V, U> where
V: Shr<u8>,
type Output = UCUM<<V as Shr<u8>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u8) -> Self::Output
[src]
fn shr(self, rhs: u8) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<u8> for UCUM<V, U> where
V: ShrAssign<u8>,
[src]
impl<V, U> ShrAssign<u8> for UCUM<V, U> where
V: ShrAssign<u8>,
fn shr_assign(&mut self, rhs: u8)
[src]
fn shr_assign(&mut self, rhs: u8)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for u8 where
u8: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for u8 where
u8: Mul<V>,
type Output = UCUM<Prod<u8, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for u8 where
u8: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for u8 where
u8: Div<V>,
U: Neg,
type Output = UCUM<Quot<u8, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for u8 where
u8: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for u8 where
u8: Rem<V>,
type Output = Unitless<<u8 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<u16> for UCUM<V, U> where
V: Add<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<u16> for UCUM<V, U> where
V: Add<u16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<u16>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: u16) -> Self::Output
[src]
fn add(self, rhs: u16) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for u16 where
u16: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for u16 where
u16: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u16 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<u16> for UCUM<V, U> where
V: AddAssign<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<u16> for UCUM<V, U> where
V: AddAssign<u16>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: u16)
[src]
fn add_assign(&mut self, rhs: u16)
Performs the +=
operation.
impl<V, U> Sub<u16> for UCUM<V, U> where
V: Sub<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<u16> for UCUM<V, U> where
V: Sub<u16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<u16>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: u16) -> Self::Output
[src]
fn sub(self, rhs: u16) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for u16 where
u16: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for u16 where
u16: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u16 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<u16> for UCUM<V, U> where
V: SubAssign<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<u16> for UCUM<V, U> where
V: SubAssign<u16>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: u16)
[src]
fn sub_assign(&mut self, rhs: u16)
Performs the -=
operation.
impl<V, U> BitAnd<u16> for UCUM<V, U> where
V: BitAnd<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<u16> for UCUM<V, U> where
V: BitAnd<u16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<u16>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: u16) -> Self::Output
[src]
fn bitand(self, rhs: u16) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for u16 where
u16: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for u16 where
u16: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u16 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<u16> for UCUM<V, U> where
V: BitAndAssign<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<u16> for UCUM<V, U> where
V: BitAndAssign<u16>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: u16)
[src]
fn bitand_assign(&mut self, rhs: u16)
Performs the &=
operation.
impl<V, U> BitOr<u16> for UCUM<V, U> where
V: BitOr<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<u16> for UCUM<V, U> where
V: BitOr<u16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<u16>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: u16) -> Self::Output
[src]
fn bitor(self, rhs: u16) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for u16 where
u16: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for u16 where
u16: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u16 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<u16> for UCUM<V, U> where
V: BitOrAssign<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<u16> for UCUM<V, U> where
V: BitOrAssign<u16>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: u16)
[src]
fn bitor_assign(&mut self, rhs: u16)
Performs the |=
operation.
impl<V, U> BitXor<u16> for UCUM<V, U> where
V: BitXor<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<u16> for UCUM<V, U> where
V: BitXor<u16>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<u16>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u16) -> Self::Output
[src]
fn bitxor(self, rhs: u16) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for u16 where
u16: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for u16 where
u16: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u16 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<u16> for UCUM<V, U> where
V: BitXorAssign<u16>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<u16> for UCUM<V, U> where
V: BitXorAssign<u16>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: u16)
[src]
fn bitxor_assign(&mut self, rhs: u16)
Performs the ^=
operation.
impl<V, U> Mul<u16> for UCUM<V, U> where
V: Mul<u16>,
[src]
impl<V, U> Mul<u16> for UCUM<V, U> where
V: Mul<u16>,
type Output = UCUM<<V as Mul<u16>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: u16) -> Self::Output
[src]
fn mul(self, rhs: u16) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<u16> for UCUM<V, U> where
V: MulAssign<u16>,
[src]
impl<V, U> MulAssign<u16> for UCUM<V, U> where
V: MulAssign<u16>,
fn mul_assign(&mut self, rhs: u16)
[src]
fn mul_assign(&mut self, rhs: u16)
Performs the *=
operation.
impl<V, U> Div<u16> for UCUM<V, U> where
V: Div<u16>,
[src]
impl<V, U> Div<u16> for UCUM<V, U> where
V: Div<u16>,
type Output = UCUM<<V as Div<u16>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: u16) -> Self::Output
[src]
fn div(self, rhs: u16) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<u16> for UCUM<V, U> where
V: DivAssign<u16>,
[src]
impl<V, U> DivAssign<u16> for UCUM<V, U> where
V: DivAssign<u16>,
fn div_assign(&mut self, rhs: u16)
[src]
fn div_assign(&mut self, rhs: u16)
Performs the /=
operation.
impl<V, U> Rem<u16> for UCUM<V, U> where
V: Rem<u16>,
[src]
impl<V, U> Rem<u16> for UCUM<V, U> where
V: Rem<u16>,
type Output = UCUM<<V as Rem<u16>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: u16) -> Self::Output
[src]
fn rem(self, rhs: u16) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<u16> for UCUM<V, U> where
V: RemAssign<u16>,
[src]
impl<V, U> RemAssign<u16> for UCUM<V, U> where
V: RemAssign<u16>,
fn rem_assign(&mut self, rhs: u16)
[src]
fn rem_assign(&mut self, rhs: u16)
Performs the %=
operation.
impl<V, U> Shl<u16> for UCUM<V, U> where
V: Shl<u16>,
[src]
impl<V, U> Shl<u16> for UCUM<V, U> where
V: Shl<u16>,
type Output = UCUM<<V as Shl<u16>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u16) -> Self::Output
[src]
fn shl(self, rhs: u16) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<u16> for UCUM<V, U> where
V: ShlAssign<u16>,
[src]
impl<V, U> ShlAssign<u16> for UCUM<V, U> where
V: ShlAssign<u16>,
fn shl_assign(&mut self, rhs: u16)
[src]
fn shl_assign(&mut self, rhs: u16)
Performs the <<=
operation.
impl<V, U> Shr<u16> for UCUM<V, U> where
V: Shr<u16>,
[src]
impl<V, U> Shr<u16> for UCUM<V, U> where
V: Shr<u16>,
type Output = UCUM<<V as Shr<u16>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u16) -> Self::Output
[src]
fn shr(self, rhs: u16) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<u16> for UCUM<V, U> where
V: ShrAssign<u16>,
[src]
impl<V, U> ShrAssign<u16> for UCUM<V, U> where
V: ShrAssign<u16>,
fn shr_assign(&mut self, rhs: u16)
[src]
fn shr_assign(&mut self, rhs: u16)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for u16 where
u16: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for u16 where
u16: Mul<V>,
type Output = UCUM<Prod<u16, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for u16 where
u16: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for u16 where
u16: Div<V>,
U: Neg,
type Output = UCUM<Quot<u16, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for u16 where
u16: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for u16 where
u16: Rem<V>,
type Output = Unitless<<u16 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<u32> for UCUM<V, U> where
V: Add<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<u32> for UCUM<V, U> where
V: Add<u32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<u32>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> Self::Output
[src]
fn add(self, rhs: u32) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for u32 where
u32: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for u32 where
u32: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u32 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<u32> for UCUM<V, U> where
V: AddAssign<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<u32> for UCUM<V, U> where
V: AddAssign<u32>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: u32)
[src]
fn add_assign(&mut self, rhs: u32)
Performs the +=
operation.
impl<V, U> Sub<u32> for UCUM<V, U> where
V: Sub<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<u32> for UCUM<V, U> where
V: Sub<u32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<u32>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> Self::Output
[src]
fn sub(self, rhs: u32) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for u32 where
u32: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for u32 where
u32: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u32 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<u32> for UCUM<V, U> where
V: SubAssign<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<u32> for UCUM<V, U> where
V: SubAssign<u32>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: u32)
[src]
fn sub_assign(&mut self, rhs: u32)
Performs the -=
operation.
impl<V, U> BitAnd<u32> for UCUM<V, U> where
V: BitAnd<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<u32> for UCUM<V, U> where
V: BitAnd<u32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<u32>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: u32) -> Self::Output
[src]
fn bitand(self, rhs: u32) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for u32 where
u32: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for u32 where
u32: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u32 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<u32> for UCUM<V, U> where
V: BitAndAssign<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<u32> for UCUM<V, U> where
V: BitAndAssign<u32>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: u32)
[src]
fn bitand_assign(&mut self, rhs: u32)
Performs the &=
operation.
impl<V, U> BitOr<u32> for UCUM<V, U> where
V: BitOr<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<u32> for UCUM<V, U> where
V: BitOr<u32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<u32>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: u32) -> Self::Output
[src]
fn bitor(self, rhs: u32) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for u32 where
u32: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for u32 where
u32: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u32 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<u32> for UCUM<V, U> where
V: BitOrAssign<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<u32> for UCUM<V, U> where
V: BitOrAssign<u32>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: u32)
[src]
fn bitor_assign(&mut self, rhs: u32)
Performs the |=
operation.
impl<V, U> BitXor<u32> for UCUM<V, U> where
V: BitXor<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<u32> for UCUM<V, U> where
V: BitXor<u32>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<u32>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u32) -> Self::Output
[src]
fn bitxor(self, rhs: u32) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for u32 where
u32: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for u32 where
u32: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u32 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<u32> for UCUM<V, U> where
V: BitXorAssign<u32>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<u32> for UCUM<V, U> where
V: BitXorAssign<u32>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: u32)
[src]
fn bitxor_assign(&mut self, rhs: u32)
Performs the ^=
operation.
impl<V, U> Mul<u32> for UCUM<V, U> where
V: Mul<u32>,
[src]
impl<V, U> Mul<u32> for UCUM<V, U> where
V: Mul<u32>,
type Output = UCUM<<V as Mul<u32>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> Self::Output
[src]
fn mul(self, rhs: u32) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<u32> for UCUM<V, U> where
V: MulAssign<u32>,
[src]
impl<V, U> MulAssign<u32> for UCUM<V, U> where
V: MulAssign<u32>,
fn mul_assign(&mut self, rhs: u32)
[src]
fn mul_assign(&mut self, rhs: u32)
Performs the *=
operation.
impl<V, U> Div<u32> for UCUM<V, U> where
V: Div<u32>,
[src]
impl<V, U> Div<u32> for UCUM<V, U> where
V: Div<u32>,
type Output = UCUM<<V as Div<u32>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> Self::Output
[src]
fn div(self, rhs: u32) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<u32> for UCUM<V, U> where
V: DivAssign<u32>,
[src]
impl<V, U> DivAssign<u32> for UCUM<V, U> where
V: DivAssign<u32>,
fn div_assign(&mut self, rhs: u32)
[src]
fn div_assign(&mut self, rhs: u32)
Performs the /=
operation.
impl<V, U> Rem<u32> for UCUM<V, U> where
V: Rem<u32>,
[src]
impl<V, U> Rem<u32> for UCUM<V, U> where
V: Rem<u32>,
type Output = UCUM<<V as Rem<u32>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> Self::Output
[src]
fn rem(self, rhs: u32) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<u32> for UCUM<V, U> where
V: RemAssign<u32>,
[src]
impl<V, U> RemAssign<u32> for UCUM<V, U> where
V: RemAssign<u32>,
fn rem_assign(&mut self, rhs: u32)
[src]
fn rem_assign(&mut self, rhs: u32)
Performs the %=
operation.
impl<V, U> Shl<u32> for UCUM<V, U> where
V: Shl<u32>,
[src]
impl<V, U> Shl<u32> for UCUM<V, U> where
V: Shl<u32>,
type Output = UCUM<<V as Shl<u32>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> Self::Output
[src]
fn shl(self, rhs: u32) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<u32> for UCUM<V, U> where
V: ShlAssign<u32>,
[src]
impl<V, U> ShlAssign<u32> for UCUM<V, U> where
V: ShlAssign<u32>,
fn shl_assign(&mut self, rhs: u32)
[src]
fn shl_assign(&mut self, rhs: u32)
Performs the <<=
operation.
impl<V, U> Shr<u32> for UCUM<V, U> where
V: Shr<u32>,
[src]
impl<V, U> Shr<u32> for UCUM<V, U> where
V: Shr<u32>,
type Output = UCUM<<V as Shr<u32>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> Self::Output
[src]
fn shr(self, rhs: u32) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<u32> for UCUM<V, U> where
V: ShrAssign<u32>,
[src]
impl<V, U> ShrAssign<u32> for UCUM<V, U> where
V: ShrAssign<u32>,
fn shr_assign(&mut self, rhs: u32)
[src]
fn shr_assign(&mut self, rhs: u32)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for u32 where
u32: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for u32 where
u32: Mul<V>,
type Output = UCUM<Prod<u32, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for u32 where
u32: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for u32 where
u32: Div<V>,
U: Neg,
type Output = UCUM<Quot<u32, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for u32 where
u32: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for u32 where
u32: Rem<V>,
type Output = Unitless<<u32 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<u64> for UCUM<V, U> where
V: Add<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<u64> for UCUM<V, U> where
V: Add<u64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<u64>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: u64) -> Self::Output
[src]
fn add(self, rhs: u64) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for u64 where
u64: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for u64 where
u64: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u64 as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<u64> for UCUM<V, U> where
V: AddAssign<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<u64> for UCUM<V, U> where
V: AddAssign<u64>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: u64)
[src]
fn add_assign(&mut self, rhs: u64)
Performs the +=
operation.
impl<V, U> Sub<u64> for UCUM<V, U> where
V: Sub<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<u64> for UCUM<V, U> where
V: Sub<u64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<u64>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: u64) -> Self::Output
[src]
fn sub(self, rhs: u64) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for u64 where
u64: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for u64 where
u64: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u64 as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<u64> for UCUM<V, U> where
V: SubAssign<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<u64> for UCUM<V, U> where
V: SubAssign<u64>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: u64)
[src]
fn sub_assign(&mut self, rhs: u64)
Performs the -=
operation.
impl<V, U> BitAnd<u64> for UCUM<V, U> where
V: BitAnd<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<u64> for UCUM<V, U> where
V: BitAnd<u64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<u64>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: u64) -> Self::Output
[src]
fn bitand(self, rhs: u64) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for u64 where
u64: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for u64 where
u64: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u64 as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<u64> for UCUM<V, U> where
V: BitAndAssign<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<u64> for UCUM<V, U> where
V: BitAndAssign<u64>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: u64)
[src]
fn bitand_assign(&mut self, rhs: u64)
Performs the &=
operation.
impl<V, U> BitOr<u64> for UCUM<V, U> where
V: BitOr<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<u64> for UCUM<V, U> where
V: BitOr<u64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<u64>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: u64) -> Self::Output
[src]
fn bitor(self, rhs: u64) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for u64 where
u64: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for u64 where
u64: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u64 as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<u64> for UCUM<V, U> where
V: BitOrAssign<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<u64> for UCUM<V, U> where
V: BitOrAssign<u64>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: u64)
[src]
fn bitor_assign(&mut self, rhs: u64)
Performs the |=
operation.
impl<V, U> BitXor<u64> for UCUM<V, U> where
V: BitXor<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<u64> for UCUM<V, U> where
V: BitXor<u64>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<u64>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u64) -> Self::Output
[src]
fn bitxor(self, rhs: u64) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for u64 where
u64: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for u64 where
u64: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<u64 as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<u64> for UCUM<V, U> where
V: BitXorAssign<u64>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<u64> for UCUM<V, U> where
V: BitXorAssign<u64>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: u64)
[src]
fn bitxor_assign(&mut self, rhs: u64)
Performs the ^=
operation.
impl<V, U> Mul<u64> for UCUM<V, U> where
V: Mul<u64>,
[src]
impl<V, U> Mul<u64> for UCUM<V, U> where
V: Mul<u64>,
type Output = UCUM<<V as Mul<u64>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: u64) -> Self::Output
[src]
fn mul(self, rhs: u64) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<u64> for UCUM<V, U> where
V: MulAssign<u64>,
[src]
impl<V, U> MulAssign<u64> for UCUM<V, U> where
V: MulAssign<u64>,
fn mul_assign(&mut self, rhs: u64)
[src]
fn mul_assign(&mut self, rhs: u64)
Performs the *=
operation.
impl<V, U> Div<u64> for UCUM<V, U> where
V: Div<u64>,
[src]
impl<V, U> Div<u64> for UCUM<V, U> where
V: Div<u64>,
type Output = UCUM<<V as Div<u64>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: u64) -> Self::Output
[src]
fn div(self, rhs: u64) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<u64> for UCUM<V, U> where
V: DivAssign<u64>,
[src]
impl<V, U> DivAssign<u64> for UCUM<V, U> where
V: DivAssign<u64>,
fn div_assign(&mut self, rhs: u64)
[src]
fn div_assign(&mut self, rhs: u64)
Performs the /=
operation.
impl<V, U> Rem<u64> for UCUM<V, U> where
V: Rem<u64>,
[src]
impl<V, U> Rem<u64> for UCUM<V, U> where
V: Rem<u64>,
type Output = UCUM<<V as Rem<u64>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: u64) -> Self::Output
[src]
fn rem(self, rhs: u64) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<u64> for UCUM<V, U> where
V: RemAssign<u64>,
[src]
impl<V, U> RemAssign<u64> for UCUM<V, U> where
V: RemAssign<u64>,
fn rem_assign(&mut self, rhs: u64)
[src]
fn rem_assign(&mut self, rhs: u64)
Performs the %=
operation.
impl<V, U> Shl<u64> for UCUM<V, U> where
V: Shl<u64>,
[src]
impl<V, U> Shl<u64> for UCUM<V, U> where
V: Shl<u64>,
type Output = UCUM<<V as Shl<u64>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u64) -> Self::Output
[src]
fn shl(self, rhs: u64) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<u64> for UCUM<V, U> where
V: ShlAssign<u64>,
[src]
impl<V, U> ShlAssign<u64> for UCUM<V, U> where
V: ShlAssign<u64>,
fn shl_assign(&mut self, rhs: u64)
[src]
fn shl_assign(&mut self, rhs: u64)
Performs the <<=
operation.
impl<V, U> Shr<u64> for UCUM<V, U> where
V: Shr<u64>,
[src]
impl<V, U> Shr<u64> for UCUM<V, U> where
V: Shr<u64>,
type Output = UCUM<<V as Shr<u64>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u64) -> Self::Output
[src]
fn shr(self, rhs: u64) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<u64> for UCUM<V, U> where
V: ShrAssign<u64>,
[src]
impl<V, U> ShrAssign<u64> for UCUM<V, U> where
V: ShrAssign<u64>,
fn shr_assign(&mut self, rhs: u64)
[src]
fn shr_assign(&mut self, rhs: u64)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for u64 where
u64: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for u64 where
u64: Mul<V>,
type Output = UCUM<Prod<u64, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for u64 where
u64: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for u64 where
u64: Div<V>,
U: Neg,
type Output = UCUM<Quot<u64, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for u64 where
u64: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for u64 where
u64: Rem<V>,
type Output = Unitless<<u64 as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<usize> for UCUM<V, U> where
V: Add<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<usize> for UCUM<V, U> where
V: Add<usize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<usize>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: usize) -> Self::Output
[src]
fn add(self, rhs: usize) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for usize where
usize: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for usize where
usize: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<usize as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<usize> for UCUM<V, U> where
V: AddAssign<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<usize> for UCUM<V, U> where
V: AddAssign<usize>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: usize)
[src]
fn add_assign(&mut self, rhs: usize)
Performs the +=
operation.
impl<V, U> Sub<usize> for UCUM<V, U> where
V: Sub<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<usize> for UCUM<V, U> where
V: Sub<usize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<usize>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: usize) -> Self::Output
[src]
fn sub(self, rhs: usize) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for usize where
usize: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for usize where
usize: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<usize as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<usize> for UCUM<V, U> where
V: SubAssign<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<usize> for UCUM<V, U> where
V: SubAssign<usize>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: usize)
[src]
fn sub_assign(&mut self, rhs: usize)
Performs the -=
operation.
impl<V, U> BitAnd<usize> for UCUM<V, U> where
V: BitAnd<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<usize> for UCUM<V, U> where
V: BitAnd<usize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<usize>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: usize) -> Self::Output
[src]
fn bitand(self, rhs: usize) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for usize where
usize: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for usize where
usize: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<usize as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<usize> for UCUM<V, U> where
V: BitAndAssign<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<usize> for UCUM<V, U> where
V: BitAndAssign<usize>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: usize)
[src]
fn bitand_assign(&mut self, rhs: usize)
Performs the &=
operation.
impl<V, U> BitOr<usize> for UCUM<V, U> where
V: BitOr<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<usize> for UCUM<V, U> where
V: BitOr<usize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<usize>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: usize) -> Self::Output
[src]
fn bitor(self, rhs: usize) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for usize where
usize: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for usize where
usize: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<usize as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<usize> for UCUM<V, U> where
V: BitOrAssign<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<usize> for UCUM<V, U> where
V: BitOrAssign<usize>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: usize)
[src]
fn bitor_assign(&mut self, rhs: usize)
Performs the |=
operation.
impl<V, U> BitXor<usize> for UCUM<V, U> where
V: BitXor<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<usize> for UCUM<V, U> where
V: BitXor<usize>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<usize>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: usize) -> Self::Output
[src]
fn bitxor(self, rhs: usize) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for usize where
usize: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for usize where
usize: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<usize as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<usize> for UCUM<V, U> where
V: BitXorAssign<usize>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<usize> for UCUM<V, U> where
V: BitXorAssign<usize>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: usize)
[src]
fn bitxor_assign(&mut self, rhs: usize)
Performs the ^=
operation.
impl<V, U> Mul<usize> for UCUM<V, U> where
V: Mul<usize>,
[src]
impl<V, U> Mul<usize> for UCUM<V, U> where
V: Mul<usize>,
type Output = UCUM<<V as Mul<usize>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: usize) -> Self::Output
[src]
fn mul(self, rhs: usize) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<usize> for UCUM<V, U> where
V: MulAssign<usize>,
[src]
impl<V, U> MulAssign<usize> for UCUM<V, U> where
V: MulAssign<usize>,
fn mul_assign(&mut self, rhs: usize)
[src]
fn mul_assign(&mut self, rhs: usize)
Performs the *=
operation.
impl<V, U> Div<usize> for UCUM<V, U> where
V: Div<usize>,
[src]
impl<V, U> Div<usize> for UCUM<V, U> where
V: Div<usize>,
type Output = UCUM<<V as Div<usize>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: usize) -> Self::Output
[src]
fn div(self, rhs: usize) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<usize> for UCUM<V, U> where
V: DivAssign<usize>,
[src]
impl<V, U> DivAssign<usize> for UCUM<V, U> where
V: DivAssign<usize>,
fn div_assign(&mut self, rhs: usize)
[src]
fn div_assign(&mut self, rhs: usize)
Performs the /=
operation.
impl<V, U> Rem<usize> for UCUM<V, U> where
V: Rem<usize>,
[src]
impl<V, U> Rem<usize> for UCUM<V, U> where
V: Rem<usize>,
type Output = UCUM<<V as Rem<usize>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: usize) -> Self::Output
[src]
fn rem(self, rhs: usize) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<usize> for UCUM<V, U> where
V: RemAssign<usize>,
[src]
impl<V, U> RemAssign<usize> for UCUM<V, U> where
V: RemAssign<usize>,
fn rem_assign(&mut self, rhs: usize)
[src]
fn rem_assign(&mut self, rhs: usize)
Performs the %=
operation.
impl<V, U> Shl<usize> for UCUM<V, U> where
V: Shl<usize>,
[src]
impl<V, U> Shl<usize> for UCUM<V, U> where
V: Shl<usize>,
type Output = UCUM<<V as Shl<usize>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: usize) -> Self::Output
[src]
fn shl(self, rhs: usize) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<usize> for UCUM<V, U> where
V: ShlAssign<usize>,
[src]
impl<V, U> ShlAssign<usize> for UCUM<V, U> where
V: ShlAssign<usize>,
fn shl_assign(&mut self, rhs: usize)
[src]
fn shl_assign(&mut self, rhs: usize)
Performs the <<=
operation.
impl<V, U> Shr<usize> for UCUM<V, U> where
V: Shr<usize>,
[src]
impl<V, U> Shr<usize> for UCUM<V, U> where
V: Shr<usize>,
type Output = UCUM<<V as Shr<usize>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: usize) -> Self::Output
[src]
fn shr(self, rhs: usize) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<usize> for UCUM<V, U> where
V: ShrAssign<usize>,
[src]
impl<V, U> ShrAssign<usize> for UCUM<V, U> where
V: ShrAssign<usize>,
fn shr_assign(&mut self, rhs: usize)
[src]
fn shr_assign(&mut self, rhs: usize)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for usize where
usize: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for usize where
usize: Mul<V>,
type Output = UCUM<Prod<usize, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for usize where
usize: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for usize where
usize: Div<V>,
U: Neg,
type Output = UCUM<Quot<usize, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for usize where
usize: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for usize where
usize: Rem<V>,
type Output = Unitless<<usize as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<bool> for UCUM<V, U> where
V: Add<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<bool> for UCUM<V, U> where
V: Add<bool>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<bool>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: bool) -> Self::Output
[src]
fn add(self, rhs: bool) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for bool where
bool: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for bool where
bool: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<bool as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<bool> for UCUM<V, U> where
V: AddAssign<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<bool> for UCUM<V, U> where
V: AddAssign<bool>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: bool)
[src]
fn add_assign(&mut self, rhs: bool)
Performs the +=
operation.
impl<V, U> Sub<bool> for UCUM<V, U> where
V: Sub<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<bool> for UCUM<V, U> where
V: Sub<bool>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<bool>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: bool) -> Self::Output
[src]
fn sub(self, rhs: bool) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for bool where
bool: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for bool where
bool: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<bool as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<bool> for UCUM<V, U> where
V: SubAssign<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<bool> for UCUM<V, U> where
V: SubAssign<bool>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: bool)
[src]
fn sub_assign(&mut self, rhs: bool)
Performs the -=
operation.
impl<V, U> BitAnd<bool> for UCUM<V, U> where
V: BitAnd<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<bool> for UCUM<V, U> where
V: BitAnd<bool>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<bool>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: bool) -> Self::Output
[src]
fn bitand(self, rhs: bool) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for bool where
bool: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for bool where
bool: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<bool as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<bool> for UCUM<V, U> where
V: BitAndAssign<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<bool> for UCUM<V, U> where
V: BitAndAssign<bool>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: bool)
[src]
fn bitand_assign(&mut self, rhs: bool)
Performs the &=
operation.
impl<V, U> BitOr<bool> for UCUM<V, U> where
V: BitOr<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<bool> for UCUM<V, U> where
V: BitOr<bool>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<bool>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: bool) -> Self::Output
[src]
fn bitor(self, rhs: bool) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for bool where
bool: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for bool where
bool: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<bool as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<bool> for UCUM<V, U> where
V: BitOrAssign<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<bool> for UCUM<V, U> where
V: BitOrAssign<bool>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: bool)
[src]
fn bitor_assign(&mut self, rhs: bool)
Performs the |=
operation.
impl<V, U> BitXor<bool> for UCUM<V, U> where
V: BitXor<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<bool> for UCUM<V, U> where
V: BitXor<bool>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<bool>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: bool) -> Self::Output
[src]
fn bitxor(self, rhs: bool) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for bool where
bool: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for bool where
bool: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<bool as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<bool> for UCUM<V, U> where
V: BitXorAssign<bool>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<bool> for UCUM<V, U> where
V: BitXorAssign<bool>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: bool)
[src]
fn bitxor_assign(&mut self, rhs: bool)
Performs the ^=
operation.
impl<V, U> Mul<bool> for UCUM<V, U> where
V: Mul<bool>,
[src]
impl<V, U> Mul<bool> for UCUM<V, U> where
V: Mul<bool>,
type Output = UCUM<<V as Mul<bool>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: bool) -> Self::Output
[src]
fn mul(self, rhs: bool) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<bool> for UCUM<V, U> where
V: MulAssign<bool>,
[src]
impl<V, U> MulAssign<bool> for UCUM<V, U> where
V: MulAssign<bool>,
fn mul_assign(&mut self, rhs: bool)
[src]
fn mul_assign(&mut self, rhs: bool)
Performs the *=
operation.
impl<V, U> Div<bool> for UCUM<V, U> where
V: Div<bool>,
[src]
impl<V, U> Div<bool> for UCUM<V, U> where
V: Div<bool>,
type Output = UCUM<<V as Div<bool>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: bool) -> Self::Output
[src]
fn div(self, rhs: bool) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<bool> for UCUM<V, U> where
V: DivAssign<bool>,
[src]
impl<V, U> DivAssign<bool> for UCUM<V, U> where
V: DivAssign<bool>,
fn div_assign(&mut self, rhs: bool)
[src]
fn div_assign(&mut self, rhs: bool)
Performs the /=
operation.
impl<V, U> Rem<bool> for UCUM<V, U> where
V: Rem<bool>,
[src]
impl<V, U> Rem<bool> for UCUM<V, U> where
V: Rem<bool>,
type Output = UCUM<<V as Rem<bool>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: bool) -> Self::Output
[src]
fn rem(self, rhs: bool) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<bool> for UCUM<V, U> where
V: RemAssign<bool>,
[src]
impl<V, U> RemAssign<bool> for UCUM<V, U> where
V: RemAssign<bool>,
fn rem_assign(&mut self, rhs: bool)
[src]
fn rem_assign(&mut self, rhs: bool)
Performs the %=
operation.
impl<V, U> Shl<bool> for UCUM<V, U> where
V: Shl<bool>,
[src]
impl<V, U> Shl<bool> for UCUM<V, U> where
V: Shl<bool>,
type Output = UCUM<<V as Shl<bool>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: bool) -> Self::Output
[src]
fn shl(self, rhs: bool) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<bool> for UCUM<V, U> where
V: ShlAssign<bool>,
[src]
impl<V, U> ShlAssign<bool> for UCUM<V, U> where
V: ShlAssign<bool>,
fn shl_assign(&mut self, rhs: bool)
[src]
fn shl_assign(&mut self, rhs: bool)
Performs the <<=
operation.
impl<V, U> Shr<bool> for UCUM<V, U> where
V: Shr<bool>,
[src]
impl<V, U> Shr<bool> for UCUM<V, U> where
V: Shr<bool>,
type Output = UCUM<<V as Shr<bool>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: bool) -> Self::Output
[src]
fn shr(self, rhs: bool) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<bool> for UCUM<V, U> where
V: ShrAssign<bool>,
[src]
impl<V, U> ShrAssign<bool> for UCUM<V, U> where
V: ShrAssign<bool>,
fn shr_assign(&mut self, rhs: bool)
[src]
fn shr_assign(&mut self, rhs: bool)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for bool where
bool: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for bool where
bool: Mul<V>,
type Output = UCUM<Prod<bool, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for bool where
bool: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for bool where
bool: Div<V>,
U: Neg,
type Output = UCUM<Quot<bool, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for bool where
bool: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for bool where
bool: Rem<V>,
type Output = Unitless<<bool as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Add<char> for UCUM<V, U> where
V: Add<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<char> for UCUM<V, U> where
V: Add<char>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Add<char>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: char) -> Self::Output
[src]
fn add(self, rhs: char) -> Self::Output
Performs the +
operation.
impl<V, U> Add<UCUM<V, U>> for char where
char: Add<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Add<UCUM<V, U>> for char where
char: Add<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<char as Add<V>>::Output, U>
The resulting type after applying the +
operator.
fn add(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn add(self, rhs: UCUM<V, U>) -> Self::Output
Performs the +
operation.
impl<V, U> AddAssign<char> for UCUM<V, U> where
V: AddAssign<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> AddAssign<char> for UCUM<V, U> where
V: AddAssign<char>,
UCUM<V, U>: Dimensionless,
fn add_assign(&mut self, rhs: char)
[src]
fn add_assign(&mut self, rhs: char)
Performs the +=
operation.
impl<V, U> Sub<char> for UCUM<V, U> where
V: Sub<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<char> for UCUM<V, U> where
V: Sub<char>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as Sub<char>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: char) -> Self::Output
[src]
fn sub(self, rhs: char) -> Self::Output
Performs the -
operation.
impl<V, U> Sub<UCUM<V, U>> for char where
char: Sub<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Sub<UCUM<V, U>> for char where
char: Sub<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<char as Sub<V>>::Output, U>
The resulting type after applying the -
operator.
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn sub(self, rhs: UCUM<V, U>) -> Self::Output
Performs the -
operation.
impl<V, U> SubAssign<char> for UCUM<V, U> where
V: SubAssign<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> SubAssign<char> for UCUM<V, U> where
V: SubAssign<char>,
UCUM<V, U>: Dimensionless,
fn sub_assign(&mut self, rhs: char)
[src]
fn sub_assign(&mut self, rhs: char)
Performs the -=
operation.
impl<V, U> BitAnd<char> for UCUM<V, U> where
V: BitAnd<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<char> for UCUM<V, U> where
V: BitAnd<char>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitAnd<char>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: char) -> Self::Output
[src]
fn bitand(self, rhs: char) -> Self::Output
Performs the &
operation.
impl<V, U> BitAnd<UCUM<V, U>> for char where
char: BitAnd<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAnd<UCUM<V, U>> for char where
char: BitAnd<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<char as BitAnd<V>>::Output, U>
The resulting type after applying the &
operator.
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitand(self, rhs: UCUM<V, U>) -> Self::Output
Performs the &
operation.
impl<V, U> BitAndAssign<char> for UCUM<V, U> where
V: BitAndAssign<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitAndAssign<char> for UCUM<V, U> where
V: BitAndAssign<char>,
UCUM<V, U>: Dimensionless,
fn bitand_assign(&mut self, rhs: char)
[src]
fn bitand_assign(&mut self, rhs: char)
Performs the &=
operation.
impl<V, U> BitOr<char> for UCUM<V, U> where
V: BitOr<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<char> for UCUM<V, U> where
V: BitOr<char>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitOr<char>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: char) -> Self::Output
[src]
fn bitor(self, rhs: char) -> Self::Output
Performs the |
operation.
impl<V, U> BitOr<UCUM<V, U>> for char where
char: BitOr<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOr<UCUM<V, U>> for char where
char: BitOr<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<char as BitOr<V>>::Output, U>
The resulting type after applying the |
operator.
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the |
operation.
impl<V, U> BitOrAssign<char> for UCUM<V, U> where
V: BitOrAssign<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitOrAssign<char> for UCUM<V, U> where
V: BitOrAssign<char>,
UCUM<V, U>: Dimensionless,
fn bitor_assign(&mut self, rhs: char)
[src]
fn bitor_assign(&mut self, rhs: char)
Performs the |=
operation.
impl<V, U> BitXor<char> for UCUM<V, U> where
V: BitXor<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<char> for UCUM<V, U> where
V: BitXor<char>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<V as BitXor<char>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: char) -> Self::Output
[src]
fn bitxor(self, rhs: char) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXor<UCUM<V, U>> for char where
char: BitXor<V>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXor<UCUM<V, U>> for char where
char: BitXor<V>,
UCUM<V, U>: Dimensionless,
type Output = UCUM<<char as BitXor<V>>::Output, U>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn bitxor(self, rhs: UCUM<V, U>) -> Self::Output
Performs the ^
operation.
impl<V, U> BitXorAssign<char> for UCUM<V, U> where
V: BitXorAssign<char>,
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> BitXorAssign<char> for UCUM<V, U> where
V: BitXorAssign<char>,
UCUM<V, U>: Dimensionless,
fn bitxor_assign(&mut self, rhs: char)
[src]
fn bitxor_assign(&mut self, rhs: char)
Performs the ^=
operation.
impl<V, U> Mul<char> for UCUM<V, U> where
V: Mul<char>,
[src]
impl<V, U> Mul<char> for UCUM<V, U> where
V: Mul<char>,
type Output = UCUM<<V as Mul<char>>::Output, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: char) -> Self::Output
[src]
fn mul(self, rhs: char) -> Self::Output
Performs the *
operation.
impl<V, U> MulAssign<char> for UCUM<V, U> where
V: MulAssign<char>,
[src]
impl<V, U> MulAssign<char> for UCUM<V, U> where
V: MulAssign<char>,
fn mul_assign(&mut self, rhs: char)
[src]
fn mul_assign(&mut self, rhs: char)
Performs the *=
operation.
impl<V, U> Div<char> for UCUM<V, U> where
V: Div<char>,
[src]
impl<V, U> Div<char> for UCUM<V, U> where
V: Div<char>,
type Output = UCUM<<V as Div<char>>::Output, U>
The resulting type after applying the /
operator.
fn div(self, rhs: char) -> Self::Output
[src]
fn div(self, rhs: char) -> Self::Output
Performs the /
operation.
impl<V, U> DivAssign<char> for UCUM<V, U> where
V: DivAssign<char>,
[src]
impl<V, U> DivAssign<char> for UCUM<V, U> where
V: DivAssign<char>,
fn div_assign(&mut self, rhs: char)
[src]
fn div_assign(&mut self, rhs: char)
Performs the /=
operation.
impl<V, U> Rem<char> for UCUM<V, U> where
V: Rem<char>,
[src]
impl<V, U> Rem<char> for UCUM<V, U> where
V: Rem<char>,
type Output = UCUM<<V as Rem<char>>::Output, U>
The resulting type after applying the %
operator.
fn rem(self, rhs: char) -> Self::Output
[src]
fn rem(self, rhs: char) -> Self::Output
Performs the %
operation.
impl<V, U> RemAssign<char> for UCUM<V, U> where
V: RemAssign<char>,
[src]
impl<V, U> RemAssign<char> for UCUM<V, U> where
V: RemAssign<char>,
fn rem_assign(&mut self, rhs: char)
[src]
fn rem_assign(&mut self, rhs: char)
Performs the %=
operation.
impl<V, U> Shl<char> for UCUM<V, U> where
V: Shl<char>,
[src]
impl<V, U> Shl<char> for UCUM<V, U> where
V: Shl<char>,
type Output = UCUM<<V as Shl<char>>::Output, U>
The resulting type after applying the <<
operator.
fn shl(self, rhs: char) -> Self::Output
[src]
fn shl(self, rhs: char) -> Self::Output
Performs the <<
operation.
impl<V, U> ShlAssign<char> for UCUM<V, U> where
V: ShlAssign<char>,
[src]
impl<V, U> ShlAssign<char> for UCUM<V, U> where
V: ShlAssign<char>,
fn shl_assign(&mut self, rhs: char)
[src]
fn shl_assign(&mut self, rhs: char)
Performs the <<=
operation.
impl<V, U> Shr<char> for UCUM<V, U> where
V: Shr<char>,
[src]
impl<V, U> Shr<char> for UCUM<V, U> where
V: Shr<char>,
type Output = UCUM<<V as Shr<char>>::Output, U>
The resulting type after applying the >>
operator.
fn shr(self, rhs: char) -> Self::Output
[src]
fn shr(self, rhs: char) -> Self::Output
Performs the >>
operation.
impl<V, U> ShrAssign<char> for UCUM<V, U> where
V: ShrAssign<char>,
[src]
impl<V, U> ShrAssign<char> for UCUM<V, U> where
V: ShrAssign<char>,
fn shr_assign(&mut self, rhs: char)
[src]
fn shr_assign(&mut self, rhs: char)
Performs the >>=
operation.
impl<V, U> Mul<UCUM<V, U>> for char where
char: Mul<V>,
[src]
impl<V, U> Mul<UCUM<V, U>> for char where
char: Mul<V>,
type Output = UCUM<Prod<char, V>, U>
The resulting type after applying the *
operator.
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn mul(self, rhs: UCUM<V, U>) -> Self::Output
Performs the *
operation.
impl<V, U> Div<UCUM<V, U>> for char where
char: Div<V>,
U: Neg,
[src]
impl<V, U> Div<UCUM<V, U>> for char where
char: Div<V>,
U: Neg,
type Output = UCUM<Quot<char, V>, <U as Neg>::Output>
The resulting type after applying the /
operator.
fn div(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn div(self, rhs: UCUM<V, U>) -> Self::Output
Performs the /
operation.
impl<V, U> Rem<UCUM<V, U>> for char where
char: Rem<V>,
[src]
impl<V, U> Rem<UCUM<V, U>> for char where
char: Rem<V>,
type Output = Unitless<<char as Rem<V>>::Output>
The resulting type after applying the %
operator.
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
[src]
fn rem(self, rhs: UCUM<V, U>) -> Self::Output
Performs the %
operation.
impl<V, U> Deref for UCUM<V, U> where
UCUM<V, U>: Dimensionless,
[src]
impl<V, U> Deref for UCUM<V, U> where
UCUM<V, U>: Dimensionless,
type Target = V
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
fn deref(&self) -> &Self::Target
Dereferences the value.
impl<V, U, Idx> Index<Idx> for UCUM<V, U> where
V: Index<Idx>,
<V as Index<Idx>>::Output: Sized,
[src]
impl<V, U, Idx> Index<Idx> for UCUM<V, U> where
V: Index<Idx>,
<V as Index<Idx>>::Output: Sized,
type Output = UCUM<<V as Index<Idx>>::Output, U>
The returned type after indexing.
fn index(&self, index: Idx) -> &Self::Output
[src]
fn index(&self, index: Idx) -> &Self::Output
Performs the indexing (container[index]
) operation.
impl<V, U, Idx> IndexMut<Idx> for UCUM<V, U> where
UCUM<V, U>: Index<Idx>,
V: Index<Idx> + IndexMut<Idx>,
<V as Index<Idx>>::Output: Sized,
<UCUM<V, U> as Index<Idx>>::Output: Sized,
[src]
impl<V, U, Idx> IndexMut<Idx> for UCUM<V, U> where
UCUM<V, U>: Index<Idx>,
V: Index<Idx> + IndexMut<Idx>,
<V as Index<Idx>>::Output: Sized,
<UCUM<V, U> as Index<Idx>>::Output: Sized,
fn index_mut(&mut self, index: Idx) -> &mut Self::Output
[src]
fn index_mut(&mut self, index: Idx) -> &mut Self::Output
Performs the mutable indexing (container[index]
) operation.
impl<V, Meter, Second, Gram, Kelvin, Coulomb, Candela> From<UCUM<V, TArr<Meter, TArr<Second, TArr<Gram, TArr<Z0, TArr<Kelvin, TArr<Coulomb, TArr<Candela, ATerm>>>>>>>>> for SI<Prod<V, f64>, TArr<Meter, TArr<Gram, TArr<Sum<Second, Coulomb>, TArr<Coulomb, TArr<Kelvin, TArr<Candela, TArr<Z0, ATerm>>>>>>>> where
Meter: Integer,
Second: Integer + Add<Coulomb>,
Gram: Integer,
Kelvin: Integer,
Coulomb: Integer,
Candela: Integer,
V: Mul<f64>,
[src]
impl<V, Meter, Second, Gram, Kelvin, Coulomb, Candela> From<UCUM<V, TArr<Meter, TArr<Second, TArr<Gram, TArr<Z0, TArr<Kelvin, TArr<Coulomb, TArr<Candela, ATerm>>>>>>>>> for SI<Prod<V, f64>, TArr<Meter, TArr<Gram, TArr<Sum<Second, Coulomb>, TArr<Coulomb, TArr<Kelvin, TArr<Candela, TArr<Z0, ATerm>>>>>>>> where
Meter: Integer,
Second: Integer + Add<Coulomb>,
Gram: Integer,
Kelvin: Integer,
Coulomb: Integer,
Candela: Integer,
V: Mul<f64>,
fn from(
other: UCUM<V, TArr<Meter, TArr<Second, TArr<Gram, TArr<Z0, TArr<Kelvin, TArr<Coulomb, TArr<Candela, ATerm>>>>>>>>
) -> Self
[src]
fn from(
other: UCUM<V, TArr<Meter, TArr<Second, TArr<Gram, TArr<Z0, TArr<Kelvin, TArr<Coulomb, TArr<Candela, ATerm>>>>>>>>
) -> Self
Performs the conversion.
impl<V, Meter, Kilogram, Second, Ampere, Kelvin, Candela> From<SI<V, TArr<Meter, TArr<Kilogram, TArr<Second, TArr<Ampere, TArr<Kelvin, TArr<Candela, TArr<Z0, ATerm>>>>>>>>> for UCUM<Prod<V, f64>, TArr<Meter, TArr<Diff<Second, Ampere>, TArr<Kilogram, TArr<Z0, TArr<Kelvin, TArr<Ampere, TArr<Candela, ATerm>>>>>>>> where
Meter: Integer,
Kilogram: Integer,
Second: Integer + Sub<Ampere>,
Ampere: Integer,
Kelvin: Integer,
Candela: Integer,
V: Mul<f64>,
[src]
impl<V, Meter, Kilogram, Second, Ampere, Kelvin, Candela> From<SI<V, TArr<Meter, TArr<Kilogram, TArr<Second, TArr<Ampere, TArr<Kelvin, TArr<Candela, TArr<Z0, ATerm>>>>>>>>> for UCUM<Prod<V, f64>, TArr<Meter, TArr<Diff<Second, Ampere>, TArr<Kilogram, TArr<Z0, TArr<Kelvin, TArr<Ampere, TArr<Candela, ATerm>>>>>>>> where
Meter: Integer,
Kilogram: Integer,
Second: Integer + Sub<Ampere>,
Ampere: Integer,
Kelvin: Integer,
Candela: Integer,
V: Mul<f64>,