Struct Division 

pub struct Division<M>
where
    M: DivisionMode,
{
    pub division_terms: RVec<DivisionTerm>,
    pub dividend: FMapping,
    pub dividend_residue: FMapping,
    pub divisor: FMapping,
    pub divisor_residue: FMapping,
    /* private fields */
}

Result of dividing two factor mappings.

Fields

division_terms: RVec<DivisionTerm>

Information about each matched divisor term.

dividend: FMapping

Original dividend before matching.

dividend_residue: FMapping

Dividend residue. Strict results preserve Bottom padding; relaxed results have all padding converted to Top.

divisor: FMapping

Original divisor before matching.

divisor_residue: FMapping

Divisor residue. Strict results preserve Bottom padding; relaxed results have all padding converted to Top.

Implementations

impl<M> Division<M>

where M: DivisionMode,

pub fn new( dividend: FMapping, dividend_residue: FMapping, division_terms: Vec<DivisionTerm>, divisor: FMapping, divisor_residue: FMapping, ) -> Division<M>

Creates a new division result.

pub fn dividend(&self) -> &FMapping

Returns the original dividend.

pub fn divisor(&self) -> &FMapping

Returns the original divisor.

pub fn residue(&self, side: DivisionSide) -> &FMapping

Returns the residue for the selected side.

pub fn mapping(&self, side: DivisionSide) -> &FMapping

Returns the original mapping for the selected side.

pub fn division_terms(&self) -> &[DivisionTerm]

Returns matched division terms in dividend-order.

Trait Implementations

impl<M> Clone for Division<M>

where M: Clone + DivisionMode,

fn clone(&self) -> Division<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Debug for Division<M>

where M: Debug + DivisionMode,

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

Formats the value using the given formatter.

impl DivisionExt<Relaxed> for Division<Relaxed>

fn exact(self) -> RResult<Division<Relaxed>, DivisionError>

Returns Ok(self) if all divisor terms were matched.

impl DivisionExt<Span> for Division<Span>

fn exact(self) -> RResult<Division<Span>, DivisionError>

Returns Ok(self) if all divisor terms were matched.

impl DivisionExt<Strict> for Division<Strict>

fn exact(self) -> RResult<Division<Strict>, DivisionError>

Returns Ok(self) if all divisor terms were matched.

impl<M> GetStaticEquivalent_ for Division<M>

where M: DivisionMode + StableAbi,

type StaticEquivalent = _static_Division<<M as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self

impl<M> StableAbi for Division<M>

where M: DivisionMode + StableAbi,

const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl StrictDivisionExt for Division<Strict>

fn bounds(&self) -> RVec<TermBounds>

Returns per-term padding bounds reconstructed from the strict residue.

This reports the compact block bounds used by remainder. For example, m![A # 16].divide_strict(m![A]).bounds() reports dividend bounds 4..16 and divisor bounds 4..4 when A = 4.

use furiosa_mapping::*;
use furiosa_opt_macro::m;

axes![A = 4];
let division = <m![A # 16]>::to_value()
    .factorize()
    .divide_strict(<m![A]>::to_value().factorize());
let [row]: [TermBounds; 1] = division.bounds().into_vec().try_into().unwrap();

assert_eq!(row.dividend, BlockBounds { min: 4, max: 16 });
assert_eq!(row.divisor, BlockBounds { min: 4, max: 4 });

fn remainder(&self, side: DivisionSide) -> FMapping

Returns the original mapping with matched terms removed.