Type Alias NonPositive 

pub type NonPositive<Input> = Sigma<Input, NonPositiveInvariant<Input>>;

Non-positive terms (defined by comparison to zero).

Aliased Type

pub struct NonPositive<Input> { /* private fields */ }

Trait Implementations

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, 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<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, 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<'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, NonPositiveInvariant<R>>> for NonPositive<L>

fn add_assign(&mut self, rhs: &'rhs NonPositive<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, NonPositiveInvariant<R>>> for NonPositive<L>

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

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, 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, 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, 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<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, 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, 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, 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<'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 NonPositive<L>

fn div_assign(&mut self, rhs: &'rhs Positive<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 NonPositive<L>

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

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, 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, 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, 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<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, 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, 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, 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<'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 NonPositive<L>

fn mul_assign(&mut self, rhs: &'rhs Positive<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 NonPositive<L>

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

Performs the *= operation.

impl<L: PartialOrd + Zero + Debug + Neg<Output: PartialOrd + Zero + Debug>> Neg for NonPositive<L>

type Output = Sigma<<L as Neg>::Output, NonNegativeInvariant<<L as Neg>::Output>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - 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, 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: 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, 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: 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, PositiveInvariant<R>>> for NonPositive<L>

fn sub_assign(&mut self, rhs: &'rhs Positive<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, PositiveInvariant<R>>> for NonPositive<L>

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

Performs the -= operation.