Struct Sigma 

pub struct Sigma<Raw: Debug, Invariant: Test<Raw, 1>> { /* private fields */ }

Type that maintains a given invariant.

Implementations

impl<Raw: Debug, Invariant: Test<Raw, 1>> Sigma<Raw, Invariant>

pub fn all<const N: usize>(array: &[Raw; N]) -> &[Self; N]

Check all elements of an array.

pub fn also<OtherInvariant: Test<Raw, 1>>(self) -> Sigma<Raw, OtherInvariant>

Without changing its internal value, view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime (iff debug assertions are enabled).

Panics

If the latter invariant does not hold.

pub fn also_ref<OtherInvariant: Test<Raw, 1>>( &self, ) -> &Sigma<Raw, OtherInvariant>

Without changing its internal value, view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime (iff debug assertions are enabled).

Panics

If the latter invariant does not hold.

pub fn check(&self)

Check an invariant if and only if debug assertions are enabled.

Panics

If the invariant does not hold and debug assertions are enabled.

pub fn get(self) -> Raw

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn get_by<Y, F: FnOnce(Raw) -> Y>(self, f: F) -> Y

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn get_by_mut<Y, F: FnOnce(&mut Raw) -> Y>(&mut self, f: F) -> Y

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn get_by_ref<Y, F: FnOnce(&Raw) -> Y>(&self, f: F) -> Y

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub const fn get_mut(&mut self) -> &mut Raw

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub const fn get_ref(&self) -> &Raw

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn map<OtherRaw: Debug, OtherInvariant: Test<OtherRaw, 1>, F: FnOnce(Raw) -> OtherRaw>( self, f: F, ) -> Sigma<OtherRaw, OtherInvariant>

Apply a function to a term that implements a given invariant (say, A), then check the output for a (possibly different) invariant (say, B).

pub fn map_mut<Y, F: FnOnce(&mut Raw) -> Y>(&mut self, f: F) -> Y

Apply a function that mutates this value, then check that the operation maintained this invariant.

pub fn map_ref<OtherRaw: Debug, OtherInvariant: Test<OtherRaw, 1>, F: FnOnce(&Raw) -> OtherRaw>( &self, f: F, ) -> Sigma<OtherRaw, OtherInvariant>

Apply a function to a term that implements a given invariant (say, A), then check the output for a (possibly different) invariant (say, B).

pub fn new(raw: Raw) -> Self

Create a new sigma type instance by checking an invariant.

Panics

If the invariant does not hold and debug assertions are enabled.

pub fn try_also<OtherInvariant: Test<Raw, 1>>( self, ) -> Result<Sigma<Raw, OtherInvariant>, Self>

Without changing its internal value, try to view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime.

Errors

If the latter invariant does not hold.

pub fn try_also_ref<OtherInvariant: Test<Raw, 1>>( &self, ) -> Result<&Sigma<Raw, OtherInvariant>, OtherInvariant::Error<'_>>

Without changing its internal value, try to view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime.

Errors

If the latter invariant does not hold.

pub fn try_check(&self) -> Result<(), Invariant::Error<'_>>

Check an invariant without panicking.

Errors

If the invariant does not hold.

pub fn try_new(raw: Raw) -> Result<Self, Raw>

Create a new sigma type instance by checking an invariant.

Errors

If the invariant does not hold. In this case, return the original input unchanged.

pub fn wrap(reference: &Raw) -> &Self

Wrap a reference through pointer reinterpretation magic.

pub fn wrap_mut(reference: &mut Raw) -> &mut Self

Wrap a reference through pointer reinterpretation magic.

Trait Implementations

impl<'rhs, L: CanBeInfinite + Debug + Add<&'rhs R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Add<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, FiniteInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs Finite<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, NegativeInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, NegativeInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, NonNegativeInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, PositiveInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, NegativeInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, NonPositiveInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, PositiveInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Add<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<&'rhs Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Add<&'rhs R>>::Output, PositiveInvariant<<L as Add<&'rhs R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the + operation.

impl<L: CanBeInfinite + Debug + Add<R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Add<Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Add<R>>::Output, FiniteInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: Finite<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Add<R>>::Output, NegativeInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: Negative<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Add<R>>::Output, NegativeInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: Negative<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Add<R>>::Output, NonNegativeInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: NonNegative<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Add<R>>::Output, PositiveInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: NonNegative<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Add<R>>::Output, NegativeInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: NonPositive<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Add<R>>::Output, NonPositiveInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: NonPositive<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Add<R>>::Output, PositiveInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: Positive<R>) -> Self::Output

Performs the + operation.

impl<L: PartialOrd + Zero + Debug + Add<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Add<Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Add<R>>::Output, PositiveInvariant<<L as Add<R>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: Positive<R>) -> Self::Output

Performs the + operation.

impl<'rhs, L: CanBeInfinite + Debug + AddAssign<&'rhs R>, R: CanBeInfinite + Debug> AddAssign<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn add_assign(&mut self, rhs: &'rhs Finite<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, NegativeInvariant<R>>> for Negative<L>

fn add_assign(&mut self, rhs: &'rhs Negative<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

fn add_assign(&mut self, rhs: &'rhs Negative<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

fn add_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

fn add_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

fn add_assign(&mut self, rhs: &'rhs NonPositive<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

fn add_assign(&mut self, rhs: &'rhs NonPositive<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

fn add_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the += operation.

impl<'rhs, L: PartialOrd + Zero + Debug + AddAssign<&'rhs R>, R: PartialOrd + Zero + Debug> AddAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for Positive<L>

fn add_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the += operation.

impl<L: CanBeInfinite + Debug + AddAssign<R>, R: CanBeInfinite + Debug> AddAssign<Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn add_assign(&mut self, rhs: Finite<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, NegativeInvariant<R>>> for Negative<L>

fn add_assign(&mut self, rhs: Negative<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

fn add_assign(&mut self, rhs: Negative<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

fn add_assign(&mut self, rhs: NonNegative<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

fn add_assign(&mut self, rhs: NonNegative<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

fn add_assign(&mut self, rhs: NonPositive<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

fn add_assign(&mut self, rhs: NonPositive<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

fn add_assign(&mut self, rhs: Positive<R>)

Performs the += operation.

impl<L: PartialOrd + Zero + Debug + AddAssign<R>, R: PartialOrd + Zero + Debug> AddAssign<Sigma<R, PositiveInvariant<R>>> for Positive<L>

fn add_assign(&mut self, rhs: Positive<R>)

Performs the += operation.

impl<Raw: Debug, Invariant: Test<Raw, 1>> AsRef<Raw> for Sigma<Raw, Invariant>

fn as_ref(&self) -> &Raw

Converts this type into a shared reference of the (usually inferred) input type.

impl<Raw: Debug, Invariant: Test<Raw, 1>> Borrow<Raw> for Sigma<Raw, Invariant>

fn borrow(&self) -> &Raw

Immutably borrows from an owned value.

impl<Raw: CanBeInfinite + Debug, Invariant: Test<Raw>> CanBeInfinite for Sigma<Raw, Invariant>

fn check_finite(&self) -> bool

Check that this value is finite (i.e. not infinite, NaN, etc).

impl<Raw: Clone + Debug, Invariant: Test<Raw, 1>> Clone for Sigma<Raw, Invariant>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Raw: Debug, Invariant: Test<Raw, 1>> Debug for Sigma<Raw, Invariant>

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

Formats the value using the given formatter.

impl<Raw: Default + Debug, Invariant: Test<Raw, 1>> Default for Sigma<Raw, Invariant>

fn default() -> Self

Returns the “default value” for a type.

impl<Raw: Debug, Invariant: Test<Raw, 1>> Deref for Sigma<Raw, Invariant>

type Target = Raw

The resulting type after dereferencing.

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

Dereferences the value.

impl<Raw: Debug + Display, Invariant: Test<Raw, 1>> Display for Sigma<Raw, Invariant>

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

Formats the value using the given formatter.

impl<'rhs, L: CanBeInfinite + Debug + Div<&'rhs R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Div<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, FiniteInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Finite<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, PositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonPositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonNegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonPositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonNegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonPositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonNegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonNegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonPositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonNegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonPositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialEq + Zero + Debug + Div<&'rhs R, Output: PartialEq + Zero + Debug>, R: PartialEq + Zero + Debug> Div<&'rhs Sigma<R, NonZeroInvariant<R>>> for NonZero<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonZeroInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs NonZero<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonNegativeInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, NonPositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Div<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<&'rhs Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<&'rhs R>>::Output, PositiveInvariant<<L as Div<&'rhs R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the / operation.

impl<L: CanBeInfinite + Debug + Div<R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Div<Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Div<R>>::Output, FiniteInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Finite<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<R>>::Output, PositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<R>>::Output, NegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonNegative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonNegative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonNegative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonNegative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonPositive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonPositive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonPositive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonPositive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialEq + Zero + Debug + Div<R, Output: PartialEq + Zero + Debug>, R: PartialEq + Zero + Debug> Div<Sigma<R, NonZeroInvariant<R>>> for NonZero<L>

type Output = Sigma<<L as Div<R>>::Output, NonZeroInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<R>>::Output, NegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<R>>::Output, PositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<'rhs, L: CanBeInfinite + Debug + DivAssign<&'rhs R>, R: CanBeInfinite + Debug> DivAssign<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn div_assign(&mut self, rhs: &'rhs Finite<R>)

Performs the /= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + DivAssign<&'rhs R>, R: PartialOrd + Zero + Debug> DivAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

fn div_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the /= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + DivAssign<&'rhs R>, R: PartialOrd + Zero + Debug> DivAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

fn div_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the /= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + DivAssign<&'rhs R>, R: PartialOrd + Zero + Debug> DivAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for Negative<L>

fn div_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the /= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + DivAssign<&'rhs R>, R: PartialOrd + Zero + Debug> DivAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

fn div_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the /= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + DivAssign<&'rhs R>, R: PartialOrd + Zero + Debug> DivAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

fn div_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the /= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + DivAssign<&'rhs R>, R: PartialOrd + Zero + Debug> DivAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for Positive<L>

fn div_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the /= operation.

impl<L: CanBeInfinite + Debug + DivAssign<R>, R: CanBeInfinite + Debug> DivAssign<Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn div_assign(&mut self, rhs: Finite<R>)

Performs the /= operation.

impl<L: PartialOrd + Zero + Debug + DivAssign<R>, R: PartialOrd + Zero + Debug> DivAssign<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

fn div_assign(&mut self, rhs: NonNegative<R>)

Performs the /= operation.

impl<L: PartialOrd + Zero + Debug + DivAssign<R>, R: PartialOrd + Zero + Debug> DivAssign<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

fn div_assign(&mut self, rhs: NonNegative<R>)

Performs the /= operation.

impl<L: PartialOrd + Zero + Debug + DivAssign<R>, R: PartialOrd + Zero + Debug> DivAssign<Sigma<R, PositiveInvariant<R>>> for Negative<L>

fn div_assign(&mut self, rhs: Positive<R>)

Performs the /= operation.

impl<L: PartialOrd + Zero + Debug + DivAssign<R>, R: PartialOrd + Zero + Debug> DivAssign<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

fn div_assign(&mut self, rhs: Positive<R>)

Performs the /= operation.

impl<L: PartialOrd + Zero + Debug + DivAssign<R>, R: PartialOrd + Zero + Debug> DivAssign<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

fn div_assign(&mut self, rhs: Positive<R>)

Performs the /= operation.

impl<L: PartialOrd + Zero + Debug + DivAssign<R>, R: PartialOrd + Zero + Debug> DivAssign<Sigma<R, PositiveInvariant<R>>> for Positive<L>

fn div_assign(&mut self, rhs: Positive<R>)

Performs the /= operation.

impl<Raw: Debug, Invariant: Test<Raw, 1>> From<Raw> for Sigma<Raw, Invariant>

fn from(value: Raw) -> Self

Converts to this type from the input type.

impl<I, Raw: FromIterator<I> + Debug, Invariant: Test<Raw, 1>> FromIterator<I> for Sigma<Raw, Invariant>

fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self

Creates a value from an iterator.

impl<Raw: Hash + Debug, Invariant: Test<Raw, 1>> Hash for Sigma<Raw, Invariant>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<Raw: IntoIterator + Debug, Invariant: Test<Raw, 1>> IntoIterator for Sigma<Raw, Invariant>

type IntoIter = <Raw as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = <Raw as IntoIterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'rhs, L: CanBeInfinite + Debug + Mul<&'rhs R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Mul<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, FiniteInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Finite<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, PositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonPositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonNegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonPositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonNegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonPositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonNegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonNegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonPositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonNegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonPositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialEq + Zero + Debug + Mul<&'rhs R, Output: PartialEq + Zero + Debug>, R: PartialEq + Zero + Debug> Mul<&'rhs Sigma<R, NonZeroInvariant<R>>> for NonZero<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonZeroInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs NonZero<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonNegativeInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, NonPositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Mul<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<&'rhs Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<&'rhs R>>::Output, PositiveInvariant<<L as Mul<&'rhs R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the * operation.

impl<L: CanBeInfinite + Debug + Mul<R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Mul<Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Mul<R>>::Output, FiniteInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Finite<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<R>>::Output, PositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<R>>::Output, NegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNegative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNegative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNegative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonNegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNegative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonPositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonPositive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonPositive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonPositive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonPositive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialEq + Zero + Debug + Mul<R, Output: PartialEq + Zero + Debug>, R: PartialEq + Zero + Debug> Mul<Sigma<R, NonZeroInvariant<R>>> for NonZero<L>

type Output = Sigma<<L as Mul<R>>::Output, NonZeroInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<R>>::Output, NegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<R>>::Output, PositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<'rhs, L: CanBeInfinite + Debug + MulAssign<&'rhs R>, R: CanBeInfinite + Debug> MulAssign<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn mul_assign(&mut self, rhs: &'rhs Finite<R>)

Performs the *= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + MulAssign<&'rhs R>, R: PartialOrd + Zero + Debug> MulAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

fn mul_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the *= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + MulAssign<&'rhs R>, R: PartialOrd + Zero + Debug> MulAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

fn mul_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the *= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + MulAssign<&'rhs R>, R: PartialOrd + Zero + Debug> MulAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for Negative<L>

fn mul_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the *= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + MulAssign<&'rhs R>, R: PartialOrd + Zero + Debug> MulAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

fn mul_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the *= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + MulAssign<&'rhs R>, R: PartialOrd + Zero + Debug> MulAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

fn mul_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the *= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + MulAssign<&'rhs R>, R: PartialOrd + Zero + Debug> MulAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for Positive<L>

fn mul_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the *= operation.

impl<L: CanBeInfinite + Debug + MulAssign<R>, R: CanBeInfinite + Debug> MulAssign<Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn mul_assign(&mut self, rhs: Finite<R>)

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + MulAssign<R>, R: PartialOrd + Zero + Debug> MulAssign<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

fn mul_assign(&mut self, rhs: NonNegative<R>)

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + MulAssign<R>, R: PartialOrd + Zero + Debug> MulAssign<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

fn mul_assign(&mut self, rhs: NonNegative<R>)

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + MulAssign<R>, R: PartialOrd + Zero + Debug> MulAssign<Sigma<R, PositiveInvariant<R>>> for Negative<L>

fn mul_assign(&mut self, rhs: Positive<R>)

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + MulAssign<R>, R: PartialOrd + Zero + Debug> MulAssign<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

fn mul_assign(&mut self, rhs: Positive<R>)

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + MulAssign<R>, R: PartialOrd + Zero + Debug> MulAssign<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

fn mul_assign(&mut self, rhs: Positive<R>)

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + MulAssign<R>, R: PartialOrd + Zero + Debug> MulAssign<Sigma<R, PositiveInvariant<R>>> for Positive<L>

fn mul_assign(&mut self, rhs: Positive<R>)

Performs the *= operation.

impl<Raw: Ord + Debug, Invariant: Test<Raw, 1>> Ord for Sigma<Raw, Invariant>

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<Raw: PartialEq + Debug, Invariant: Test<Raw, 1>> PartialEq for Sigma<Raw, Invariant>

fn eq(&self, other: &Self) -> bool

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

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

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

impl<Raw: PartialOrd + Debug, Invariant: Test<Raw, 1>> PartialOrd for Sigma<Raw, Invariant>

fn ge(&self, other: &Self) -> bool

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

fn gt(&self, other: &Self) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn le(&self, other: &Self) -> bool

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

fn lt(&self, other: &Self) -> bool

Tests less than (for self and other) and is used by the < operator.

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

impl<'rhs, L: CanBeInfinite + Debug + Sub<&'rhs R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Sub<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, FiniteInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs Finite<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, PositiveInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, PositiveInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs Negative<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, NegativeInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, NonPositiveInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs NonNegative<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, NonNegativeInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, PositiveInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs NonPositive<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, NegativeInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: PartialOrd + Zero + Debug + Sub<&'rhs R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<&'rhs Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Sub<&'rhs R>>::Output, NegativeInvariant<<L as Sub<&'rhs R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs Positive<R>) -> Self::Output

Performs the - operation.

impl<L: CanBeInfinite + Debug + Sub<R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Sub<Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Sub<R>>::Output, FiniteInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: Finite<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Sub<R>>::Output, PositiveInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: Negative<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Sub<R>>::Output, PositiveInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: Negative<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Sub<R>>::Output, NegativeInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonNegative<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Sub<R>>::Output, NonPositiveInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonNegative<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Sub<R>>::Output, NonNegativeInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonPositive<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Sub<R>>::Output, PositiveInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonPositive<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Sub<R>>::Output, NegativeInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: Positive<R>) -> Self::Output

Performs the - operation.

impl<L: PartialOrd + Zero + Debug + Sub<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Sub<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Sub<R>>::Output, NegativeInvariant<<L as Sub<R>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: Positive<R>) -> Self::Output

Performs the - operation.

impl<'rhs, L: CanBeInfinite + Debug + SubAssign<&'rhs R>, R: CanBeInfinite + Debug> SubAssign<&'rhs Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn sub_assign(&mut self, rhs: &'rhs Finite<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

fn sub_assign(&mut self, rhs: &'rhs Negative<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, NegativeInvariant<R>>> for Positive<L>

fn sub_assign(&mut self, rhs: &'rhs Negative<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

fn sub_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

fn sub_assign(&mut self, rhs: &'rhs NonNegative<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

fn sub_assign(&mut self, rhs: &'rhs NonPositive<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

fn sub_assign(&mut self, rhs: &'rhs NonPositive<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for Negative<L>

fn sub_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the -= operation.

impl<'rhs, L: PartialOrd + Zero + Debug + SubAssign<&'rhs R>, R: PartialOrd + Zero + Debug> SubAssign<&'rhs Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

fn sub_assign(&mut self, rhs: &'rhs Positive<R>)

Performs the -= operation.

impl<L: CanBeInfinite + Debug + SubAssign<R>, R: CanBeInfinite + Debug> SubAssign<Sigma<R, FiniteInvariant<R>>> for Finite<L>

fn sub_assign(&mut self, rhs: Finite<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

fn sub_assign(&mut self, rhs: Negative<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, NegativeInvariant<R>>> for Positive<L>

fn sub_assign(&mut self, rhs: Negative<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, NonNegativeInvariant<R>>> for Negative<L>

fn sub_assign(&mut self, rhs: NonNegative<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

fn sub_assign(&mut self, rhs: NonNegative<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

fn sub_assign(&mut self, rhs: NonPositive<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, NonPositiveInvariant<R>>> for Positive<L>

fn sub_assign(&mut self, rhs: NonPositive<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, PositiveInvariant<R>>> for Negative<L>

fn sub_assign(&mut self, rhs: Positive<R>)

Performs the -= operation.

impl<L: PartialOrd + Zero + Debug + SubAssign<R>, R: PartialOrd + Zero + Debug> SubAssign<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

fn sub_assign(&mut self, rhs: Positive<R>)

Performs the -= operation.

impl<Raw: Copy + Debug, Invariant: Test<Raw, 1>> Copy for Sigma<Raw, Invariant>

impl<Raw: Eq + Debug, Invariant: Test<Raw, 1>> Eq for Sigma<Raw, Invariant>