Struct MulExpression 

pub struct MulExpression<L, R> {
    pub lhs: L,
    pub rhs: R,
}

An expression representing deferred multiplication.

The exact product is kept until the expression is converted to a target resolution or assigned to a FastFixed variable, so the result format does not depend on operand order.

Fields

lhs: L

The left-hand factor of the multiplication expression.

rhs: R

The right-hand factor of the multiplication expression.

Trait Implementations

impl<L, R, E> Add<E> for MulExpression<L, R>

where MulExpression<L, R>: FastExpression, E: FastExpression,

type Output = SumExpression<MulExpression<L, R>, E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I, const FRAC: usize, L, R> Add<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + Copy, MulExpression<L, R>: FastExpression, FastFixed<I, FRAC>: Add<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<I, FRAC>) -> Self::Output

Performs the + operation.

impl<L: Clone, R: Clone> Clone for MulExpression<L, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Copy, R: Copy> Copy for MulExpression<L, R>

impl<T, const FL: usize, U, const FR: usize> FastExpression for MulExpression<FastFixed<T, FL>, FastFixed<U, FR>>

where T: PromoteMul<U> + Zero + PartialOrd + NumCast + Copy, U: Zero + PartialOrd + NumCast + Copy, <T as PromoteMul<U>>::Output: FastInt,

const FRAC: usize

The number of fractional bits of the raw value produced by evaluate_raw.

type Int = <<T as PromoteMul<U>>::Output as FastInt>::Intermediate

The 64-bit intermediate integer type the expression is evaluated in.

fn evaluate_raw(self) -> Self::Int

Evaluates the expression to its raw value with Self::FRAC fractional bits.

fn evaluate<I, const FRAC_OUT: usize>(self) -> FastFixed<I, FRAC_OUT>

where I: Bounded + NumCast + Copy,

Evaluates the expression into the given FastFixed format, rounding half to even exactly once and saturating when the value does not fit.

impl<I, const FRAC_OUT: usize, L, R> From<MulExpression<L, R>> for FastFixed<I, FRAC_OUT>

where I: Bounded + NumCast + Copy, MulExpression<L, R>: FastExpression,

fn from(expr: MulExpression<L, R>) -> Self

Converts to this type from the input type.

impl<I, const FRAC: usize, L, R> PartialEq<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + PartialEq + Copy, MulExpression<L, R>: FastExpression,

fn eq(&self, other: &FastFixed<I, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I, const FRAC: usize, L, R> PartialOrd<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + PartialOrd + Copy, MulExpression<L, R>: FastExpression,

fn partial_cmp(&self, other: &FastFixed<I, FRAC>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<L, R, E> Sub<E> for MulExpression<L, R>

where MulExpression<L, R>: FastExpression, E: FastExpression,

type Output = SumExpression<MulExpression<L, R>, E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I, const FRAC: usize, L, R> Sub<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + Copy, MulExpression<L, R>: FastExpression, FastFixed<I, FRAC>: Sub<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<I, FRAC>) -> Self::Output

Performs the - operation.