Struct NonZeroFactorization 

pub struct NonZeroFactorization<Factor, Power, Residual> {
    pub sign: NonZeroSign,
    pub factors: Vec<(Factor, Power)>,
    pub residual: Residual,
}

Factorization of a nonzero integer or rational number.

Includes a sign.

Invariant

The three fields together always describe the entire value:

value == sign * residual * product(factor ^ power)

The factorization routines are deliberately incomplete, because splitting a large cofactor is expensive. Whatever they did not decompose is in residual rather than dropped, so the identity above holds regardless of how they were tuned. Use Self::is_complete to find out whether the value was decomposed entirely.

Fields

sign: NonZeroSign

Whether the number is negative.

factors: Vec<(Factor, Power)>

(factor, power) tuples.

These factors are often, but not necessarily, primes; they are all larger than 1. The factors should all be smaller than 64 bits and can have negative powers; that is, appear in the denominator. The powers can’t be zero, as this is a sparse representation.

When this field is empty, nothing was decomposed and the value is sign * residual. In particular, an empty list does not mean that the value is 1 or -1; that is the case only when the residual is one as well.

residual: Residual

The part of the value that was not decomposed.

One exactly when the factors describe the entire value, see Self::is_complete. It is always positive; the sign of the value is in sign.

Implementations

impl<Factor, Power, Residual: FactorizationResidual> NonZeroFactorization<Factor, Power, Residual>

pub fn is_complete(&self) -> bool

Whether the value was decomposed entirely, that is, whether the residual is one.

When this is false, the factors describe only the part of the value that could be split off cheaply, and multiplying them together does not reproduce the value: the residual is the missing factor.

Trait Implementations

impl<Factor: Clone, Power: Clone, Residual: Clone> Clone for NonZeroFactorization<Factor, Power, Residual>

fn clone(&self) -> NonZeroFactorization<Factor, Power, Residual>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Factor: Debug, Power: Debug, Residual: Debug> Debug for NonZeroFactorization<Factor, Power, Residual>

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

Formats the value using the given formatter.

impl<Factor: Eq, Power: Eq, Residual: Eq> Eq for NonZeroFactorization<Factor, Power, Residual>

impl<Factor: PartialEq, Power: PartialEq, Residual: PartialEq> PartialEq for NonZeroFactorization<Factor, Power, Residual>

fn eq(&self, other: &NonZeroFactorization<Factor, Power, Residual>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<Factor: PartialEq, Power: PartialEq, Residual: PartialEq> StructuralPartialEq for NonZeroFactorization<Factor, Power, Residual>