Struct SumExpression 

pub struct SumExpression<L, R> { /* private fields */ }

A deferred sum or difference of two FastFixed expressions.

The operands are aligned to the lesser of their precisions before the addition, as in the C++ library.

Trait Implementations

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

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

type Output = SumExpression<SumExpression<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 SumExpression<L, R>

where I: Bounded + NumCast + Copy, SumExpression<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 SumExpression<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 SumExpression<L, R>

impl<L, R> FastExpression for SumExpression<L, R>

where L: FastExpression, R: FastExpression<Int = L::Int>,

const FRAC: usize

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

type Int = <L as FastExpression>::Int

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<SumExpression<L, R>> for FastFixed<I, FRAC_OUT>

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

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

Converts to this type from the input type.

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

where I: Bounded + NumCast + PartialEq + Copy, SumExpression<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 SumExpression<L, R>

where I: Bounded + NumCast + PartialOrd + Copy, SumExpression<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 SumExpression<L, R>

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

type Output = SumExpression<SumExpression<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 SumExpression<L, R>

where I: Bounded + NumCast + Copy, SumExpression<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.