Struct Fraction 

pub struct Fraction<T> {
    pub num: T,
    pub den: T,
}

A numerator paired with its denominator.

Fractional addition never touches one half alone:

    a_0/b_0 + a_1/b_1 = (a_0*b_1 + a_1*b_0) / (b_0*b_1)

So the two travel together, through every layer and every claim. Pairing them in one type makes a half-formed pair unrepresentable. A bare tuple leaves each caller to remember which element is which.

T is whatever stands for one half. A scalar gives a claimed fraction; a column buffer gives one layer of the circuit.

Fields

num: T

The numerator.

den: T

The denominator.

Implementations

impl<T> Fraction<T>

pub const fn new(num: T, den: T) -> Self

Pairs a numerator with a denominator.

pub const fn as_ref(&self) -> Fraction<&T>

Borrows both halves, so a fraction can be read without moving out of it.

pub fn map<U>(self, f: impl FnMut(T) -> U) -> Fraction<U>

Applies f to each half.

This is how a fraction changes representation, such as a pair of layer buffers reduced to the pair of scalars at their root.

impl<F: Field> Fraction<F>

pub const ZERO: Self

The zero fraction $0/1$.

This is the additive identity of fractional addition: adding it changes nothing. So it is what a padding leaf holds when a batch lifts a shallow tree to its depth, and what fills the selector slots past the last real instance.

Trait Implementations

impl<T: Clone> Clone for Fraction<T>

fn clone(&self) -> Fraction<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Fraction<T>

impl<T: Debug> Debug for Fraction<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Fraction<T>

impl<T> From<(T, T)> for Fraction<T>

fn from((num, den): (T, T)) -> Self

Converts to this type from the input type.

impl<T> From<Fraction<T>> for (T, T)

fn from(_: Fraction<T>) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Fraction<T>

fn eq(&self, other: &Fraction<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialEq> StructuralPartialEq for Fraction<T>