Struct dimensioned::unit_systems::fps::FPS

pub struct FPS<V, U> {
    pub value_unsafe: V,
    pub _marker: PhantomData<U>,
}

The $System 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> FPS<V, U>

fn new(v: V) -> Self

Create a new quantity in the $System unit system

Trait Implementations

impl<V, U1, U2, U3> Display for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: Display,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> Octal for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: Octal,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> LowerHex for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: LowerHex,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> UpperHex for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: UpperHex,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> Pointer for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: Pointer,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> Binary for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: Binary,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> LowerExp for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: LowerExp,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V, U1, U2, U3> UpperExp for FPS<V, TArr<U1, TArr<U2, TArr<U3, ATerm>>>> where
    V: UpperExp,
    U1: Integer,
    U2: Integer,
    U3: Integer, 

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

Formats the value using the given formatter.

impl<V: Eq, U: Eq> Eq for FPS<V, U>

impl<V: PartialEq, U: PartialEq> PartialEq for FPS<V, U>

fn eq(&self, __arg_0: &FPS<V, U>) -> bool

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

fn ne(&self, __arg_0: &FPS<V, U>) -> bool

This method tests for !=.

impl<V: Ord, U: Ord> Ord for FPS<V, U>

fn cmp(&self, __arg_0: &FPS<V, U>) -> Ordering

This method returns an Ordering between self and other.

impl<V: PartialOrd, U: PartialOrd> PartialOrd for FPS<V, U>

fn partial_cmp(&self, __arg_0: &FPS<V, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &FPS<V, U>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &FPS<V, U>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &FPS<V, U>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &FPS<V, U>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<V: Clone, U: Clone> Clone for FPS<V, U>

fn clone(&self) -> FPS<V, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Copy, U: Copy> Copy for FPS<V, U>

impl<V: Hash, U: Hash> Hash for FPS<V, U>

fn hash<__HVU: Hasher>(&self, __arg_0: &mut __HVU)

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<V, U> Dimensioned for FPS<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].

fn new(val: V) -> Self

Construct a new quantity.

fn value_unsafe(&self) -> &V

Extract the value from a quantity. As this ignores the units completely, it is dimensionally unsafe.

impl<ValueIn, UnitsIn, ValueOut, UnitsOut> MapUnsafe<ValueOut, UnitsOut> for FPS<ValueIn, UnitsIn>

type Output = FPS<ValueOut, UnitsOut>

The type to which the input is mapped

fn map_unsafe<F: FnOnce(ValueIn) -> ValueOut>(self, f: F) -> Self::Output

Perform the map

impl<V, U> Debug for FPS<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>

Formats the value using the given formatter.

impl<V, U> Recip for FPS<V, U> where
    V: Recip,
    U: Neg, 

type Output = FPS<<V as Recip>::Output, Negate<U>>

The resulting type after taking the reciprocal

fn recip(self) -> Self::Output

The method for taking the reciprocal

impl<Exp, V, U> Pow<Exp> for FPS<V, U> where
    V: Pow<Exp>,
    U: Mul<Exp>, 

type Output = FPS<<V as Pow<Exp>>::Output, Prod<U, Exp>>

The result of the exponentiation.

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.

impl<Index, V, U> Root<Index> for FPS<V, U> where
    V: Root<Index>,
    U: PartialDiv<Index>, 

type Output = FPS<<V as Root<Index>>::Output, PartialQuot<U, Index>>

The resulting type after taking the Index root

fn root(self, idx: Index) -> Self::Output

The method for taking the idx root

impl<V, U> Sqrt for FPS<V, U> where
    V: Sqrt,
    U: PartialDiv<P2>, 

type Output = FPS<<V as Sqrt>::Output, PartialQuot<U, P2>>

The resulting type after taking the square root

fn sqrt(self) -> Self::Output

The method for taking the square root

impl<V, U> Cbrt for FPS<V, U> where
    V: Cbrt,
    U: PartialDiv<P3>, 

type Output = FPS<<V as Cbrt>::Output, PartialQuot<U, P3>>

The resulting type after taking the cube root

fn cbrt(self) -> Self::Output

The method for taking the cube root

impl<V, U> Not for FPS<V, U> where
    V: Not, 

type Output = FPS<<V as Not>::Output, U>

The resulting type after applying the ! operator

fn not(self) -> Self::Output

The method for the unary ! operator

impl<V, U> Neg for FPS<V, U> where
    V: Neg, 

type Output = FPS<<V as Neg>::Output, U>

The resulting type after applying the - operator

fn neg(self) -> Self::Output

The method for the unary - operator

impl<Vl, U, Vr> Add<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: Add<Vr>, 

type Output = FPS<<Vl as Add<Vr>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: FPS<Vr, U>) -> Self::Output

The method for the + operator

impl<Vl, U, Vr> AddAssign<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: AddAssign<Vr>, 

fn add_assign(&mut self, rhs: FPS<Vr, U>)

The method for the += operator

impl<Vl, U, Vr> Sub<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: Sub<Vr>, 

type Output = FPS<<Vl as Sub<Vr>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: FPS<Vr, U>) -> Self::Output

The method for the - operator

impl<Vl, U, Vr> SubAssign<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: SubAssign<Vr>, 

fn sub_assign(&mut self, rhs: FPS<Vr, U>)

The method for the -= operator

impl<Vl, U, Vr> BitAnd<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: BitAnd<Vr>, 

type Output = FPS<<Vl as BitAnd<Vr>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: FPS<Vr, U>) -> Self::Output

The method for the & operator

impl<Vl, U, Vr> BitAndAssign<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: BitAndAssign<Vr>, 

fn bitand_assign(&mut self, rhs: FPS<Vr, U>)

The method for the &= operator

impl<Vl, U, Vr> BitOr<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: BitOr<Vr>, 

type Output = FPS<<Vl as BitOr<Vr>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: FPS<Vr, U>) -> Self::Output

The method for the | operator

impl<Vl, U, Vr> BitOrAssign<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: BitOrAssign<Vr>, 

fn bitor_assign(&mut self, rhs: FPS<Vr, U>)

The method for the |= operator

impl<Vl, U, Vr> BitXor<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: BitXor<Vr>, 

type Output = FPS<<Vl as BitXor<Vr>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: FPS<Vr, U>) -> Self::Output

The method for the ^ operator

impl<Vl, U, Vr> BitXorAssign<FPS<Vr, U>> for FPS<Vl, U> where
    Vl: BitXorAssign<Vr>, 

fn bitxor_assign(&mut self, rhs: FPS<Vr, U>)

The method for the ^= operator

impl<Vl, Ul, Vr, Ur> Mul<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: Mul<Vr>,
    Ul: Add<Ur>, 

type Output = FPS<<Vl as Mul<Vr>>::Output, <Ul as Add<Ur>>::Output>

The resulting type after applying the * operator

fn mul(self, rhs: FPS<Vr, Ur>) -> Self::Output

The method for the * operator

impl<Vl, Ul, Vr, Ur> MulAssign<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: MulAssign<Vr>,
    FPS<Vr, Ur>: Dimensionless, 

fn mul_assign(&mut self, rhs: FPS<Vr, Ur>)

The method for the *= operator

impl<Vl, Ul, Vr, Ur> Div<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: Div<Vr>,
    Ul: Sub<Ur>, 

type Output = FPS<<Vl as Div<Vr>>::Output, <Ul as Sub<Ur>>::Output>

The resulting type after applying the / operator

fn div(self, rhs: FPS<Vr, Ur>) -> Self::Output

The method for the / operator

impl<Vl, Ul, Vr, Ur> DivAssign<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: DivAssign<Vr>,
    FPS<Vr, Ur>: Dimensionless, 

fn div_assign(&mut self, rhs: FPS<Vr, Ur>)

The method for the /= operator

impl<Vl, Ul, Vr, Ur> Rem<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: Rem<Vr>, 

type Output = FPS<<Vl as Rem<Vr>>::Output, Ul>

The resulting type after applying the % operator

fn rem(self, rhs: FPS<Vr, Ur>) -> Self::Output

The method for the % operator

impl<Vl, Ul, Vr, Ur> RemAssign<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: RemAssign<Vr>, 

fn rem_assign(&mut self, rhs: FPS<Vr, Ur>)

The method for the %= operator

impl<Vl, Ul, Vr, Ur> Shl<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: Shl<Vr>,
    FPS<Vr, Ur>: Dimensionless, 

type Output = FPS<<Vl as Shl<Vr>>::Output, Ul>

The resulting type after applying the << operator

fn shl(self, rhs: FPS<Vr, Ur>) -> Self::Output

The method for the << operator

impl<Vl, Ul, Vr, Ur> ShlAssign<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: ShlAssign<Vr>,
    FPS<Vr, Ur>: Dimensionless, 

fn shl_assign(&mut self, rhs: FPS<Vr, Ur>)

The method for the <<= operator

impl<Vl, Ul, Vr, Ur> Shr<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: Shr<Vr>,
    FPS<Vr, Ur>: Dimensionless, 

type Output = FPS<<Vl as Shr<Vr>>::Output, Ul>

The resulting type after applying the >> operator

fn shr(self, rhs: FPS<Vr, Ur>) -> Self::Output

The method for the >> operator

impl<Vl, Ul, Vr, Ur> ShrAssign<FPS<Vr, Ur>> for FPS<Vl, Ul> where
    Vl: ShrAssign<Vr>,
    FPS<Vr, Ur>: Dimensionless, 

fn shr_assign(&mut self, rhs: FPS<Vr, Ur>)

The method for the >>= operator

impl<V, U> Add<f32> for FPS<V, U> where
    V: Add<f32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<f32>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: f32) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<f32> for FPS<V, U> where
    V: AddAssign<f32>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: f32)

The method for the += operator

impl<V, U> Sub<f32> for FPS<V, U> where
    V: Sub<f32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<f32>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: f32) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<f32> for FPS<V, U> where
    V: SubAssign<f32>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: f32)

The method for the -= operator

impl<V, U> BitAnd<f32> for FPS<V, U> where
    V: BitAnd<f32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<f32>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: f32) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<f32> for FPS<V, U> where
    V: BitAndAssign<f32>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: f32)

The method for the &= operator

impl<V, U> BitOr<f32> for FPS<V, U> where
    V: BitOr<f32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<f32>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: f32) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<f32> for FPS<V, U> where
    V: BitOrAssign<f32>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: f32)

The method for the |= operator

impl<V, U> BitXor<f32> for FPS<V, U> where
    V: BitXor<f32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<f32>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: f32) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<f32> for FPS<V, U> where
    V: BitXorAssign<f32>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: f32)

The method for the ^= operator

impl<V, U> Mul<f32> for FPS<V, U> where
    V: Mul<f32>, 

type Output = FPS<<V as Mul<f32>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: f32) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<f32> for FPS<V, U> where
    V: MulAssign<f32>, 

fn mul_assign(&mut self, rhs: f32)

The method for the *= operator

impl<V, U> Div<f32> for FPS<V, U> where
    V: Div<f32>, 

type Output = FPS<<V as Div<f32>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: f32) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<f32> for FPS<V, U> where
    V: DivAssign<f32>, 

fn div_assign(&mut self, rhs: f32)

The method for the /= operator

impl<V, U> Rem<f32> for FPS<V, U> where
    V: Rem<f32>, 

type Output = FPS<<V as Rem<f32>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: f32) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<f32> for FPS<V, U> where
    V: RemAssign<f32>, 

fn rem_assign(&mut self, rhs: f32)

The method for the %= operator

impl<V, U> Shl<f32> for FPS<V, U> where
    V: Shl<f32>, 

type Output = FPS<<V as Shl<f32>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: f32) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<f32> for FPS<V, U> where
    V: ShlAssign<f32>, 

fn shl_assign(&mut self, rhs: f32)

The method for the <<= operator

impl<V, U> Shr<f32> for FPS<V, U> where
    V: Shr<f32>, 

type Output = FPS<<V as Shr<f32>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: f32) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<f32> for FPS<V, U> where
    V: ShrAssign<f32>, 

fn shr_assign(&mut self, rhs: f32)

The method for the >>= operator

impl<V, U> Add<f64> for FPS<V, U> where
    V: Add<f64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<f64>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: f64) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<f64> for FPS<V, U> where
    V: AddAssign<f64>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: f64)

The method for the += operator

impl<V, U> Sub<f64> for FPS<V, U> where
    V: Sub<f64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<f64>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: f64) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<f64> for FPS<V, U> where
    V: SubAssign<f64>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: f64)

The method for the -= operator

impl<V, U> BitAnd<f64> for FPS<V, U> where
    V: BitAnd<f64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<f64>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: f64) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<f64> for FPS<V, U> where
    V: BitAndAssign<f64>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: f64)

The method for the &= operator

impl<V, U> BitOr<f64> for FPS<V, U> where
    V: BitOr<f64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<f64>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: f64) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<f64> for FPS<V, U> where
    V: BitOrAssign<f64>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: f64)

The method for the |= operator

impl<V, U> BitXor<f64> for FPS<V, U> where
    V: BitXor<f64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<f64>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: f64) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<f64> for FPS<V, U> where
    V: BitXorAssign<f64>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: f64)

The method for the ^= operator

impl<V, U> Mul<f64> for FPS<V, U> where
    V: Mul<f64>, 

type Output = FPS<<V as Mul<f64>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: f64) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<f64> for FPS<V, U> where
    V: MulAssign<f64>, 

fn mul_assign(&mut self, rhs: f64)

The method for the *= operator

impl<V, U> Div<f64> for FPS<V, U> where
    V: Div<f64>, 

type Output = FPS<<V as Div<f64>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: f64) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<f64> for FPS<V, U> where
    V: DivAssign<f64>, 

fn div_assign(&mut self, rhs: f64)

The method for the /= operator

impl<V, U> Rem<f64> for FPS<V, U> where
    V: Rem<f64>, 

type Output = FPS<<V as Rem<f64>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: f64) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<f64> for FPS<V, U> where
    V: RemAssign<f64>, 

fn rem_assign(&mut self, rhs: f64)

The method for the %= operator

impl<V, U> Shl<f64> for FPS<V, U> where
    V: Shl<f64>, 

type Output = FPS<<V as Shl<f64>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: f64) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<f64> for FPS<V, U> where
    V: ShlAssign<f64>, 

fn shl_assign(&mut self, rhs: f64)

The method for the <<= operator

impl<V, U> Shr<f64> for FPS<V, U> where
    V: Shr<f64>, 

type Output = FPS<<V as Shr<f64>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: f64) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<f64> for FPS<V, U> where
    V: ShrAssign<f64>, 

fn shr_assign(&mut self, rhs: f64)

The method for the >>= operator

impl<V, U> Add<i8> for FPS<V, U> where
    V: Add<i8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<i8>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: i8) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<i8> for FPS<V, U> where
    V: AddAssign<i8>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: i8)

The method for the += operator

impl<V, U> Sub<i8> for FPS<V, U> where
    V: Sub<i8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<i8>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: i8) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<i8> for FPS<V, U> where
    V: SubAssign<i8>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: i8)

The method for the -= operator

impl<V, U> BitAnd<i8> for FPS<V, U> where
    V: BitAnd<i8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<i8>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: i8) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<i8> for FPS<V, U> where
    V: BitAndAssign<i8>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: i8)

The method for the &= operator

impl<V, U> BitOr<i8> for FPS<V, U> where
    V: BitOr<i8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<i8>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: i8) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<i8> for FPS<V, U> where
    V: BitOrAssign<i8>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: i8)

The method for the |= operator

impl<V, U> BitXor<i8> for FPS<V, U> where
    V: BitXor<i8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<i8>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: i8) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<i8> for FPS<V, U> where
    V: BitXorAssign<i8>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: i8)

The method for the ^= operator

impl<V, U> Mul<i8> for FPS<V, U> where
    V: Mul<i8>, 

type Output = FPS<<V as Mul<i8>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: i8) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<i8> for FPS<V, U> where
    V: MulAssign<i8>, 

fn mul_assign(&mut self, rhs: i8)

The method for the *= operator

impl<V, U> Div<i8> for FPS<V, U> where
    V: Div<i8>, 

type Output = FPS<<V as Div<i8>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: i8) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<i8> for FPS<V, U> where
    V: DivAssign<i8>, 

fn div_assign(&mut self, rhs: i8)

The method for the /= operator

impl<V, U> Rem<i8> for FPS<V, U> where
    V: Rem<i8>, 

type Output = FPS<<V as Rem<i8>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: i8) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<i8> for FPS<V, U> where
    V: RemAssign<i8>, 

fn rem_assign(&mut self, rhs: i8)

The method for the %= operator

impl<V, U> Shl<i8> for FPS<V, U> where
    V: Shl<i8>, 

type Output = FPS<<V as Shl<i8>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: i8) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<i8> for FPS<V, U> where
    V: ShlAssign<i8>, 

fn shl_assign(&mut self, rhs: i8)

The method for the <<= operator

impl<V, U> Shr<i8> for FPS<V, U> where
    V: Shr<i8>, 

type Output = FPS<<V as Shr<i8>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: i8) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<i8> for FPS<V, U> where
    V: ShrAssign<i8>, 

fn shr_assign(&mut self, rhs: i8)

The method for the >>= operator

impl<V, U> Add<i16> for FPS<V, U> where
    V: Add<i16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<i16>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: i16) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<i16> for FPS<V, U> where
    V: AddAssign<i16>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: i16)

The method for the += operator

impl<V, U> Sub<i16> for FPS<V, U> where
    V: Sub<i16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<i16>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: i16) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<i16> for FPS<V, U> where
    V: SubAssign<i16>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: i16)

The method for the -= operator

impl<V, U> BitAnd<i16> for FPS<V, U> where
    V: BitAnd<i16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<i16>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: i16) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<i16> for FPS<V, U> where
    V: BitAndAssign<i16>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: i16)

The method for the &= operator

impl<V, U> BitOr<i16> for FPS<V, U> where
    V: BitOr<i16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<i16>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: i16) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<i16> for FPS<V, U> where
    V: BitOrAssign<i16>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: i16)

The method for the |= operator

impl<V, U> BitXor<i16> for FPS<V, U> where
    V: BitXor<i16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<i16>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: i16) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<i16> for FPS<V, U> where
    V: BitXorAssign<i16>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: i16)

The method for the ^= operator

impl<V, U> Mul<i16> for FPS<V, U> where
    V: Mul<i16>, 

type Output = FPS<<V as Mul<i16>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: i16) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<i16> for FPS<V, U> where
    V: MulAssign<i16>, 

fn mul_assign(&mut self, rhs: i16)

The method for the *= operator

impl<V, U> Div<i16> for FPS<V, U> where
    V: Div<i16>, 

type Output = FPS<<V as Div<i16>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: i16) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<i16> for FPS<V, U> where
    V: DivAssign<i16>, 

fn div_assign(&mut self, rhs: i16)

The method for the /= operator

impl<V, U> Rem<i16> for FPS<V, U> where
    V: Rem<i16>, 

type Output = FPS<<V as Rem<i16>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: i16) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<i16> for FPS<V, U> where
    V: RemAssign<i16>, 

fn rem_assign(&mut self, rhs: i16)

The method for the %= operator

impl<V, U> Shl<i16> for FPS<V, U> where
    V: Shl<i16>, 

type Output = FPS<<V as Shl<i16>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: i16) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<i16> for FPS<V, U> where
    V: ShlAssign<i16>, 

fn shl_assign(&mut self, rhs: i16)

The method for the <<= operator

impl<V, U> Shr<i16> for FPS<V, U> where
    V: Shr<i16>, 

type Output = FPS<<V as Shr<i16>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: i16) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<i16> for FPS<V, U> where
    V: ShrAssign<i16>, 

fn shr_assign(&mut self, rhs: i16)

The method for the >>= operator

impl<V, U> Add<i32> for FPS<V, U> where
    V: Add<i32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<i32>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: i32) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<i32> for FPS<V, U> where
    V: AddAssign<i32>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: i32)

The method for the += operator

impl<V, U> Sub<i32> for FPS<V, U> where
    V: Sub<i32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<i32>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: i32) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<i32> for FPS<V, U> where
    V: SubAssign<i32>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: i32)

The method for the -= operator

impl<V, U> BitAnd<i32> for FPS<V, U> where
    V: BitAnd<i32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<i32>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: i32) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<i32> for FPS<V, U> where
    V: BitAndAssign<i32>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: i32)

The method for the &= operator

impl<V, U> BitOr<i32> for FPS<V, U> where
    V: BitOr<i32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<i32>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: i32) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<i32> for FPS<V, U> where
    V: BitOrAssign<i32>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: i32)

The method for the |= operator

impl<V, U> BitXor<i32> for FPS<V, U> where
    V: BitXor<i32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<i32>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: i32) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<i32> for FPS<V, U> where
    V: BitXorAssign<i32>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: i32)

The method for the ^= operator

impl<V, U> Mul<i32> for FPS<V, U> where
    V: Mul<i32>, 

type Output = FPS<<V as Mul<i32>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: i32) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<i32> for FPS<V, U> where
    V: MulAssign<i32>, 

fn mul_assign(&mut self, rhs: i32)

The method for the *= operator

impl<V, U> Div<i32> for FPS<V, U> where
    V: Div<i32>, 

type Output = FPS<<V as Div<i32>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: i32) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<i32> for FPS<V, U> where
    V: DivAssign<i32>, 

fn div_assign(&mut self, rhs: i32)

The method for the /= operator

impl<V, U> Rem<i32> for FPS<V, U> where
    V: Rem<i32>, 

type Output = FPS<<V as Rem<i32>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: i32) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<i32> for FPS<V, U> where
    V: RemAssign<i32>, 

fn rem_assign(&mut self, rhs: i32)

The method for the %= operator

impl<V, U> Shl<i32> for FPS<V, U> where
    V: Shl<i32>, 

type Output = FPS<<V as Shl<i32>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: i32) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<i32> for FPS<V, U> where
    V: ShlAssign<i32>, 

fn shl_assign(&mut self, rhs: i32)

The method for the <<= operator

impl<V, U> Shr<i32> for FPS<V, U> where
    V: Shr<i32>, 

type Output = FPS<<V as Shr<i32>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: i32) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<i32> for FPS<V, U> where
    V: ShrAssign<i32>, 

fn shr_assign(&mut self, rhs: i32)

The method for the >>= operator

impl<V, U> Add<i64> for FPS<V, U> where
    V: Add<i64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<i64>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: i64) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<i64> for FPS<V, U> where
    V: AddAssign<i64>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: i64)

The method for the += operator

impl<V, U> Sub<i64> for FPS<V, U> where
    V: Sub<i64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<i64>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: i64) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<i64> for FPS<V, U> where
    V: SubAssign<i64>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: i64)

The method for the -= operator

impl<V, U> BitAnd<i64> for FPS<V, U> where
    V: BitAnd<i64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<i64>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: i64) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<i64> for FPS<V, U> where
    V: BitAndAssign<i64>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: i64)

The method for the &= operator

impl<V, U> BitOr<i64> for FPS<V, U> where
    V: BitOr<i64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<i64>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: i64) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<i64> for FPS<V, U> where
    V: BitOrAssign<i64>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: i64)

The method for the |= operator

impl<V, U> BitXor<i64> for FPS<V, U> where
    V: BitXor<i64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<i64>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: i64) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<i64> for FPS<V, U> where
    V: BitXorAssign<i64>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: i64)

The method for the ^= operator

impl<V, U> Mul<i64> for FPS<V, U> where
    V: Mul<i64>, 

type Output = FPS<<V as Mul<i64>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: i64) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<i64> for FPS<V, U> where
    V: MulAssign<i64>, 

fn mul_assign(&mut self, rhs: i64)

The method for the *= operator

impl<V, U> Div<i64> for FPS<V, U> where
    V: Div<i64>, 

type Output = FPS<<V as Div<i64>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: i64) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<i64> for FPS<V, U> where
    V: DivAssign<i64>, 

fn div_assign(&mut self, rhs: i64)

The method for the /= operator

impl<V, U> Rem<i64> for FPS<V, U> where
    V: Rem<i64>, 

type Output = FPS<<V as Rem<i64>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: i64) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<i64> for FPS<V, U> where
    V: RemAssign<i64>, 

fn rem_assign(&mut self, rhs: i64)

The method for the %= operator

impl<V, U> Shl<i64> for FPS<V, U> where
    V: Shl<i64>, 

type Output = FPS<<V as Shl<i64>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: i64) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<i64> for FPS<V, U> where
    V: ShlAssign<i64>, 

fn shl_assign(&mut self, rhs: i64)

The method for the <<= operator

impl<V, U> Shr<i64> for FPS<V, U> where
    V: Shr<i64>, 

type Output = FPS<<V as Shr<i64>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: i64) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<i64> for FPS<V, U> where
    V: ShrAssign<i64>, 

fn shr_assign(&mut self, rhs: i64)

The method for the >>= operator

impl<V, U> Add<isize> for FPS<V, U> where
    V: Add<isize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<isize>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: isize) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<isize> for FPS<V, U> where
    V: AddAssign<isize>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: isize)

The method for the += operator

impl<V, U> Sub<isize> for FPS<V, U> where
    V: Sub<isize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<isize>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: isize) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<isize> for FPS<V, U> where
    V: SubAssign<isize>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: isize)

The method for the -= operator

impl<V, U> BitAnd<isize> for FPS<V, U> where
    V: BitAnd<isize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<isize>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: isize) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<isize> for FPS<V, U> where
    V: BitAndAssign<isize>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: isize)

The method for the &= operator

impl<V, U> BitOr<isize> for FPS<V, U> where
    V: BitOr<isize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<isize>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: isize) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<isize> for FPS<V, U> where
    V: BitOrAssign<isize>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: isize)

The method for the |= operator

impl<V, U> BitXor<isize> for FPS<V, U> where
    V: BitXor<isize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<isize>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: isize) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<isize> for FPS<V, U> where
    V: BitXorAssign<isize>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: isize)

The method for the ^= operator

impl<V, U> Mul<isize> for FPS<V, U> where
    V: Mul<isize>, 

type Output = FPS<<V as Mul<isize>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: isize) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<isize> for FPS<V, U> where
    V: MulAssign<isize>, 

fn mul_assign(&mut self, rhs: isize)

The method for the *= operator

impl<V, U> Div<isize> for FPS<V, U> where
    V: Div<isize>, 

type Output = FPS<<V as Div<isize>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: isize) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<isize> for FPS<V, U> where
    V: DivAssign<isize>, 

fn div_assign(&mut self, rhs: isize)

The method for the /= operator

impl<V, U> Rem<isize> for FPS<V, U> where
    V: Rem<isize>, 

type Output = FPS<<V as Rem<isize>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: isize) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<isize> for FPS<V, U> where
    V: RemAssign<isize>, 

fn rem_assign(&mut self, rhs: isize)

The method for the %= operator

impl<V, U> Shl<isize> for FPS<V, U> where
    V: Shl<isize>, 

type Output = FPS<<V as Shl<isize>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: isize) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<isize> for FPS<V, U> where
    V: ShlAssign<isize>, 

fn shl_assign(&mut self, rhs: isize)

The method for the <<= operator

impl<V, U> Shr<isize> for FPS<V, U> where
    V: Shr<isize>, 

type Output = FPS<<V as Shr<isize>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: isize) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<isize> for FPS<V, U> where
    V: ShrAssign<isize>, 

fn shr_assign(&mut self, rhs: isize)

The method for the >>= operator

impl<V, U> Add<u8> for FPS<V, U> where
    V: Add<u8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<u8>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: u8) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<u8> for FPS<V, U> where
    V: AddAssign<u8>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: u8)

The method for the += operator

impl<V, U> Sub<u8> for FPS<V, U> where
    V: Sub<u8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<u8>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: u8) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<u8> for FPS<V, U> where
    V: SubAssign<u8>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: u8)

The method for the -= operator

impl<V, U> BitAnd<u8> for FPS<V, U> where
    V: BitAnd<u8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<u8>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: u8) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<u8> for FPS<V, U> where
    V: BitAndAssign<u8>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: u8)

The method for the &= operator

impl<V, U> BitOr<u8> for FPS<V, U> where
    V: BitOr<u8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<u8>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: u8) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<u8> for FPS<V, U> where
    V: BitOrAssign<u8>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: u8)

The method for the |= operator

impl<V, U> BitXor<u8> for FPS<V, U> where
    V: BitXor<u8>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<u8>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: u8) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<u8> for FPS<V, U> where
    V: BitXorAssign<u8>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: u8)

The method for the ^= operator

impl<V, U> Mul<u8> for FPS<V, U> where
    V: Mul<u8>, 

type Output = FPS<<V as Mul<u8>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: u8) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<u8> for FPS<V, U> where
    V: MulAssign<u8>, 

fn mul_assign(&mut self, rhs: u8)

The method for the *= operator

impl<V, U> Div<u8> for FPS<V, U> where
    V: Div<u8>, 

type Output = FPS<<V as Div<u8>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: u8) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<u8> for FPS<V, U> where
    V: DivAssign<u8>, 

fn div_assign(&mut self, rhs: u8)

The method for the /= operator

impl<V, U> Rem<u8> for FPS<V, U> where
    V: Rem<u8>, 

type Output = FPS<<V as Rem<u8>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: u8) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<u8> for FPS<V, U> where
    V: RemAssign<u8>, 

fn rem_assign(&mut self, rhs: u8)

The method for the %= operator

impl<V, U> Shl<u8> for FPS<V, U> where
    V: Shl<u8>, 

type Output = FPS<<V as Shl<u8>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: u8) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<u8> for FPS<V, U> where
    V: ShlAssign<u8>, 

fn shl_assign(&mut self, rhs: u8)

The method for the <<= operator

impl<V, U> Shr<u8> for FPS<V, U> where
    V: Shr<u8>, 

type Output = FPS<<V as Shr<u8>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: u8) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<u8> for FPS<V, U> where
    V: ShrAssign<u8>, 

fn shr_assign(&mut self, rhs: u8)

The method for the >>= operator

impl<V, U> Add<u16> for FPS<V, U> where
    V: Add<u16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<u16>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: u16) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<u16> for FPS<V, U> where
    V: AddAssign<u16>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: u16)

The method for the += operator

impl<V, U> Sub<u16> for FPS<V, U> where
    V: Sub<u16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<u16>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: u16) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<u16> for FPS<V, U> where
    V: SubAssign<u16>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: u16)

The method for the -= operator

impl<V, U> BitAnd<u16> for FPS<V, U> where
    V: BitAnd<u16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<u16>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: u16) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<u16> for FPS<V, U> where
    V: BitAndAssign<u16>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: u16)

The method for the &= operator

impl<V, U> BitOr<u16> for FPS<V, U> where
    V: BitOr<u16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<u16>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: u16) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<u16> for FPS<V, U> where
    V: BitOrAssign<u16>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: u16)

The method for the |= operator

impl<V, U> BitXor<u16> for FPS<V, U> where
    V: BitXor<u16>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<u16>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: u16) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<u16> for FPS<V, U> where
    V: BitXorAssign<u16>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: u16)

The method for the ^= operator

impl<V, U> Mul<u16> for FPS<V, U> where
    V: Mul<u16>, 

type Output = FPS<<V as Mul<u16>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: u16) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<u16> for FPS<V, U> where
    V: MulAssign<u16>, 

fn mul_assign(&mut self, rhs: u16)

The method for the *= operator

impl<V, U> Div<u16> for FPS<V, U> where
    V: Div<u16>, 

type Output = FPS<<V as Div<u16>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: u16) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<u16> for FPS<V, U> where
    V: DivAssign<u16>, 

fn div_assign(&mut self, rhs: u16)

The method for the /= operator

impl<V, U> Rem<u16> for FPS<V, U> where
    V: Rem<u16>, 

type Output = FPS<<V as Rem<u16>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: u16) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<u16> for FPS<V, U> where
    V: RemAssign<u16>, 

fn rem_assign(&mut self, rhs: u16)

The method for the %= operator

impl<V, U> Shl<u16> for FPS<V, U> where
    V: Shl<u16>, 

type Output = FPS<<V as Shl<u16>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: u16) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<u16> for FPS<V, U> where
    V: ShlAssign<u16>, 

fn shl_assign(&mut self, rhs: u16)

The method for the <<= operator

impl<V, U> Shr<u16> for FPS<V, U> where
    V: Shr<u16>, 

type Output = FPS<<V as Shr<u16>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: u16) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<u16> for FPS<V, U> where
    V: ShrAssign<u16>, 

fn shr_assign(&mut self, rhs: u16)

The method for the >>= operator

impl<V, U> Add<u32> for FPS<V, U> where
    V: Add<u32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<u32>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: u32) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<u32> for FPS<V, U> where
    V: AddAssign<u32>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: u32)

The method for the += operator

impl<V, U> Sub<u32> for FPS<V, U> where
    V: Sub<u32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<u32>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: u32) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<u32> for FPS<V, U> where
    V: SubAssign<u32>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: u32)

The method for the -= operator

impl<V, U> BitAnd<u32> for FPS<V, U> where
    V: BitAnd<u32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<u32>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: u32) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<u32> for FPS<V, U> where
    V: BitAndAssign<u32>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: u32)

The method for the &= operator

impl<V, U> BitOr<u32> for FPS<V, U> where
    V: BitOr<u32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<u32>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: u32) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<u32> for FPS<V, U> where
    V: BitOrAssign<u32>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: u32)

The method for the |= operator

impl<V, U> BitXor<u32> for FPS<V, U> where
    V: BitXor<u32>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<u32>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: u32) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<u32> for FPS<V, U> where
    V: BitXorAssign<u32>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: u32)

The method for the ^= operator

impl<V, U> Mul<u32> for FPS<V, U> where
    V: Mul<u32>, 

type Output = FPS<<V as Mul<u32>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: u32) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<u32> for FPS<V, U> where
    V: MulAssign<u32>, 

fn mul_assign(&mut self, rhs: u32)

The method for the *= operator

impl<V, U> Div<u32> for FPS<V, U> where
    V: Div<u32>, 

type Output = FPS<<V as Div<u32>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: u32) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<u32> for FPS<V, U> where
    V: DivAssign<u32>, 

fn div_assign(&mut self, rhs: u32)

The method for the /= operator

impl<V, U> Rem<u32> for FPS<V, U> where
    V: Rem<u32>, 

type Output = FPS<<V as Rem<u32>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: u32) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<u32> for FPS<V, U> where
    V: RemAssign<u32>, 

fn rem_assign(&mut self, rhs: u32)

The method for the %= operator

impl<V, U> Shl<u32> for FPS<V, U> where
    V: Shl<u32>, 

type Output = FPS<<V as Shl<u32>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: u32) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<u32> for FPS<V, U> where
    V: ShlAssign<u32>, 

fn shl_assign(&mut self, rhs: u32)

The method for the <<= operator

impl<V, U> Shr<u32> for FPS<V, U> where
    V: Shr<u32>, 

type Output = FPS<<V as Shr<u32>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: u32) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<u32> for FPS<V, U> where
    V: ShrAssign<u32>, 

fn shr_assign(&mut self, rhs: u32)

The method for the >>= operator

impl<V, U> Add<u64> for FPS<V, U> where
    V: Add<u64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<u64>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: u64) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<u64> for FPS<V, U> where
    V: AddAssign<u64>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: u64)

The method for the += operator

impl<V, U> Sub<u64> for FPS<V, U> where
    V: Sub<u64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<u64>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: u64) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<u64> for FPS<V, U> where
    V: SubAssign<u64>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: u64)

The method for the -= operator

impl<V, U> BitAnd<u64> for FPS<V, U> where
    V: BitAnd<u64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<u64>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: u64) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<u64> for FPS<V, U> where
    V: BitAndAssign<u64>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: u64)

The method for the &= operator

impl<V, U> BitOr<u64> for FPS<V, U> where
    V: BitOr<u64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<u64>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: u64) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<u64> for FPS<V, U> where
    V: BitOrAssign<u64>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: u64)

The method for the |= operator

impl<V, U> BitXor<u64> for FPS<V, U> where
    V: BitXor<u64>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<u64>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: u64) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<u64> for FPS<V, U> where
    V: BitXorAssign<u64>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: u64)

The method for the ^= operator

impl<V, U> Mul<u64> for FPS<V, U> where
    V: Mul<u64>, 

type Output = FPS<<V as Mul<u64>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: u64) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<u64> for FPS<V, U> where
    V: MulAssign<u64>, 

fn mul_assign(&mut self, rhs: u64)

The method for the *= operator

impl<V, U> Div<u64> for FPS<V, U> where
    V: Div<u64>, 

type Output = FPS<<V as Div<u64>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: u64) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<u64> for FPS<V, U> where
    V: DivAssign<u64>, 

fn div_assign(&mut self, rhs: u64)

The method for the /= operator

impl<V, U> Rem<u64> for FPS<V, U> where
    V: Rem<u64>, 

type Output = FPS<<V as Rem<u64>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: u64) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<u64> for FPS<V, U> where
    V: RemAssign<u64>, 

fn rem_assign(&mut self, rhs: u64)

The method for the %= operator

impl<V, U> Shl<u64> for FPS<V, U> where
    V: Shl<u64>, 

type Output = FPS<<V as Shl<u64>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: u64) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<u64> for FPS<V, U> where
    V: ShlAssign<u64>, 

fn shl_assign(&mut self, rhs: u64)

The method for the <<= operator

impl<V, U> Shr<u64> for FPS<V, U> where
    V: Shr<u64>, 

type Output = FPS<<V as Shr<u64>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: u64) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<u64> for FPS<V, U> where
    V: ShrAssign<u64>, 

fn shr_assign(&mut self, rhs: u64)

The method for the >>= operator

impl<V, U> Add<usize> for FPS<V, U> where
    V: Add<usize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<usize>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: usize) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<usize> for FPS<V, U> where
    V: AddAssign<usize>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: usize)

The method for the += operator

impl<V, U> Sub<usize> for FPS<V, U> where
    V: Sub<usize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<usize>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: usize) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<usize> for FPS<V, U> where
    V: SubAssign<usize>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: usize)

The method for the -= operator

impl<V, U> BitAnd<usize> for FPS<V, U> where
    V: BitAnd<usize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<usize>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: usize) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<usize> for FPS<V, U> where
    V: BitAndAssign<usize>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: usize)

The method for the &= operator

impl<V, U> BitOr<usize> for FPS<V, U> where
    V: BitOr<usize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<usize>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: usize) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<usize> for FPS<V, U> where
    V: BitOrAssign<usize>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: usize)

The method for the |= operator

impl<V, U> BitXor<usize> for FPS<V, U> where
    V: BitXor<usize>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<usize>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: usize) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<usize> for FPS<V, U> where
    V: BitXorAssign<usize>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: usize)

The method for the ^= operator

impl<V, U> Mul<usize> for FPS<V, U> where
    V: Mul<usize>, 

type Output = FPS<<V as Mul<usize>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: usize) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<usize> for FPS<V, U> where
    V: MulAssign<usize>, 

fn mul_assign(&mut self, rhs: usize)

The method for the *= operator

impl<V, U> Div<usize> for FPS<V, U> where
    V: Div<usize>, 

type Output = FPS<<V as Div<usize>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: usize) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<usize> for FPS<V, U> where
    V: DivAssign<usize>, 

fn div_assign(&mut self, rhs: usize)

The method for the /= operator

impl<V, U> Rem<usize> for FPS<V, U> where
    V: Rem<usize>, 

type Output = FPS<<V as Rem<usize>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: usize) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<usize> for FPS<V, U> where
    V: RemAssign<usize>, 

fn rem_assign(&mut self, rhs: usize)

The method for the %= operator

impl<V, U> Shl<usize> for FPS<V, U> where
    V: Shl<usize>, 

type Output = FPS<<V as Shl<usize>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: usize) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<usize> for FPS<V, U> where
    V: ShlAssign<usize>, 

fn shl_assign(&mut self, rhs: usize)

The method for the <<= operator

impl<V, U> Shr<usize> for FPS<V, U> where
    V: Shr<usize>, 

type Output = FPS<<V as Shr<usize>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: usize) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<usize> for FPS<V, U> where
    V: ShrAssign<usize>, 

fn shr_assign(&mut self, rhs: usize)

The method for the >>= operator

impl<V, U> Add<bool> for FPS<V, U> where
    V: Add<bool>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<bool>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: bool) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<bool> for FPS<V, U> where
    V: AddAssign<bool>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: bool)

The method for the += operator

impl<V, U> Sub<bool> for FPS<V, U> where
    V: Sub<bool>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<bool>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: bool) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<bool> for FPS<V, U> where
    V: SubAssign<bool>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: bool)

The method for the -= operator

impl<V, U> BitAnd<bool> for FPS<V, U> where
    V: BitAnd<bool>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<bool>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: bool) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<bool> for FPS<V, U> where
    V: BitAndAssign<bool>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: bool)

The method for the &= operator

impl<V, U> BitOr<bool> for FPS<V, U> where
    V: BitOr<bool>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<bool>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: bool) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<bool> for FPS<V, U> where
    V: BitOrAssign<bool>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: bool)

The method for the |= operator

impl<V, U> BitXor<bool> for FPS<V, U> where
    V: BitXor<bool>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<bool>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: bool) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<bool> for FPS<V, U> where
    V: BitXorAssign<bool>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: bool)

The method for the ^= operator

impl<V, U> Mul<bool> for FPS<V, U> where
    V: Mul<bool>, 

type Output = FPS<<V as Mul<bool>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: bool) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<bool> for FPS<V, U> where
    V: MulAssign<bool>, 

fn mul_assign(&mut self, rhs: bool)

The method for the *= operator

impl<V, U> Div<bool> for FPS<V, U> where
    V: Div<bool>, 

type Output = FPS<<V as Div<bool>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: bool) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<bool> for FPS<V, U> where
    V: DivAssign<bool>, 

fn div_assign(&mut self, rhs: bool)

The method for the /= operator

impl<V, U> Rem<bool> for FPS<V, U> where
    V: Rem<bool>, 

type Output = FPS<<V as Rem<bool>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: bool) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<bool> for FPS<V, U> where
    V: RemAssign<bool>, 

fn rem_assign(&mut self, rhs: bool)

The method for the %= operator

impl<V, U> Shl<bool> for FPS<V, U> where
    V: Shl<bool>, 

type Output = FPS<<V as Shl<bool>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: bool) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<bool> for FPS<V, U> where
    V: ShlAssign<bool>, 

fn shl_assign(&mut self, rhs: bool)

The method for the <<= operator

impl<V, U> Shr<bool> for FPS<V, U> where
    V: Shr<bool>, 

type Output = FPS<<V as Shr<bool>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: bool) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<bool> for FPS<V, U> where
    V: ShrAssign<bool>, 

fn shr_assign(&mut self, rhs: bool)

The method for the >>= operator

impl<V, U> Add<char> for FPS<V, U> where
    V: Add<char>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Add<char>>::Output, U>

The resulting type after applying the + operator

fn add(self, rhs: char) -> Self::Output

The method for the + operator

impl<V, U> AddAssign<char> for FPS<V, U> where
    V: AddAssign<char>,
    FPS<V, U>: Dimensionless, 

fn add_assign(&mut self, rhs: char)

The method for the += operator

impl<V, U> Sub<char> for FPS<V, U> where
    V: Sub<char>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as Sub<char>>::Output, U>

The resulting type after applying the - operator

fn sub(self, rhs: char) -> Self::Output

The method for the - operator

impl<V, U> SubAssign<char> for FPS<V, U> where
    V: SubAssign<char>,
    FPS<V, U>: Dimensionless, 

fn sub_assign(&mut self, rhs: char)

The method for the -= operator

impl<V, U> BitAnd<char> for FPS<V, U> where
    V: BitAnd<char>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitAnd<char>>::Output, U>

The resulting type after applying the & operator

fn bitand(self, rhs: char) -> Self::Output

The method for the & operator

impl<V, U> BitAndAssign<char> for FPS<V, U> where
    V: BitAndAssign<char>,
    FPS<V, U>: Dimensionless, 

fn bitand_assign(&mut self, rhs: char)

The method for the &= operator

impl<V, U> BitOr<char> for FPS<V, U> where
    V: BitOr<char>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitOr<char>>::Output, U>

The resulting type after applying the | operator

fn bitor(self, rhs: char) -> Self::Output

The method for the | operator

impl<V, U> BitOrAssign<char> for FPS<V, U> where
    V: BitOrAssign<char>,
    FPS<V, U>: Dimensionless, 

fn bitor_assign(&mut self, rhs: char)

The method for the |= operator

impl<V, U> BitXor<char> for FPS<V, U> where
    V: BitXor<char>,
    FPS<V, U>: Dimensionless, 

type Output = FPS<<V as BitXor<char>>::Output, U>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: char) -> Self::Output

The method for the ^ operator

impl<V, U> BitXorAssign<char> for FPS<V, U> where
    V: BitXorAssign<char>,
    FPS<V, U>: Dimensionless, 

fn bitxor_assign(&mut self, rhs: char)

The method for the ^= operator

impl<V, U> Mul<char> for FPS<V, U> where
    V: Mul<char>, 

type Output = FPS<<V as Mul<char>>::Output, U>

The resulting type after applying the * operator

fn mul(self, rhs: char) -> Self::Output

The method for the * operator

impl<V, U> MulAssign<char> for FPS<V, U> where
    V: MulAssign<char>, 

fn mul_assign(&mut self, rhs: char)

The method for the *= operator

impl<V, U> Div<char> for FPS<V, U> where
    V: Div<char>, 

type Output = FPS<<V as Div<char>>::Output, U>

The resulting type after applying the / operator

fn div(self, rhs: char) -> Self::Output

The method for the / operator

impl<V, U> DivAssign<char> for FPS<V, U> where
    V: DivAssign<char>, 

fn div_assign(&mut self, rhs: char)

The method for the /= operator

impl<V, U> Rem<char> for FPS<V, U> where
    V: Rem<char>, 

type Output = FPS<<V as Rem<char>>::Output, U>

The resulting type after applying the % operator

fn rem(self, rhs: char) -> Self::Output

The method for the % operator

impl<V, U> RemAssign<char> for FPS<V, U> where
    V: RemAssign<char>, 

fn rem_assign(&mut self, rhs: char)

The method for the %= operator

impl<V, U> Shl<char> for FPS<V, U> where
    V: Shl<char>, 

type Output = FPS<<V as Shl<char>>::Output, U>

The resulting type after applying the << operator

fn shl(self, rhs: char) -> Self::Output

The method for the << operator

impl<V, U> ShlAssign<char> for FPS<V, U> where
    V: ShlAssign<char>, 

fn shl_assign(&mut self, rhs: char)

The method for the <<= operator

impl<V, U> Shr<char> for FPS<V, U> where
    V: Shr<char>, 

type Output = FPS<<V as Shr<char>>::Output, U>

The resulting type after applying the >> operator

fn shr(self, rhs: char) -> Self::Output

The method for the >> operator

impl<V, U> ShrAssign<char> for FPS<V, U> where
    V: ShrAssign<char>, 

fn shr_assign(&mut self, rhs: char)

The method for the >>= operator

impl<V, U> Deref for FPS<V, U> where
    FPS<V, U>: Dimensionless, 

type Target = V

The resulting type after dereferencing

fn deref(&self) -> &Self::Target

The method called to dereference a value

impl<V, U, Idx> Index<Idx> for FPS<V, U> where
    V: Index<Idx>,
    <V as Index<Idx>>::Output: Sized, 

type Output = FPS<<V as Index<Idx>>::Output, U>

The returned type after indexing

fn index(&self, index: Idx) -> &Self::Output

The method for the indexing (container[index]) operation

impl<V, U, Idx> IndexMut<Idx> for FPS<V, U> where
    FPS<V, U>: Index<Idx>,
    V: Index<Idx> + IndexMut<Idx>,
    <V as Index<Idx>>::Output: Sized,
    <FPS<V, U> as Index<Idx>>::Output: Sized, 

fn index_mut(&mut self, index: Idx) -> &mut Self::Output

The method for the mutable indexing (container[index]) operation