Struct Rational 

pub struct Rational { /* private fields */ }

A reduced rational number with i128 numerator and positive i128 denominator.

Trait arithmetic panics when an intermediate or result leaves the fixed-width carrier; the checked_* methods expose the same boundary as Option.

Implementations

impl Rational

pub fn try_new(num: i128, den: i128) -> Option<Self>

Construct num / den in lowest terms.

Returns None for a zero denominator or if sign normalization cannot be represented in i128.

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

Construct num / den in lowest terms.

Panics for a zero denominator or unrepresentable sign normalization; use try_new for a checked result.

pub fn sign(&self) -> Ordering

Sign as an Ordering relative to zero (den is always > 0).

pub fn is_integer(&self) -> bool

True iff this rational is a (rational) integer, i.e. its denominator is 1. Used by the omnific-integer backend to test the constant CNF term.

pub fn numer(&self) -> i128

The numerator (in lowest terms; carries the sign).

pub fn denom(&self) -> i128

The denominator (in lowest terms; always > 0).

pub fn cmp(&self, other: &Self) -> Ordering

Total order on values (denominator is always positive).

pub fn floor(&self) -> i128

The greatest integer ≤ this rational.

pub fn sqrt(&self) -> Option<Rational>

The exact rational square root, or None if it is not a perfect square in ℚ (numerator and denominator both perfect squares, and self ≥ 0). √2 is None here on purpose: it is not rational. This is what bounds the surreal sqrt to the ℚ-coefficient subclass.

pub fn nth_root(&self, k: u128) -> Option<Rational>

The exact rational k-th root, or None if it is not a perfect k-th power in ℚ (even k requires self ≥ 0).

pub fn checked_add(&self, rhs: &Self) -> Option<Self>

Checked addition: None on i128 overflow instead of panicking. The Scalar::add impl is a thin .expect() wrapper over this.

pub fn checked_mul(&self, rhs: &Self) -> Option<Self>

Checked multiplication: None on i128 overflow instead of panicking. Cross-reduces first (gcd(a,d), gcd(c,b)) to keep intermediates small, the same cross-gcd-reduction the Scalar::mul impl (a thin .expect() wrapper over this) exposes.

Trait Implementations

impl Add for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> Rational

Performs the + operation.

impl BitXor<u128> for Rational

fn bitxor(self, k: u128) -> Rational

Square-and-multiply power: x ^ 0 == one(), x ^ k via Scalar::pow.

^ is power (grundy ↑). The RHS is u128 so element-element ^ does not compile — no BitXor<Self> impl exists on any backend. Precedence caveat: Rust’s ^ binds looser than *; parenthesize when mixing with product.

type Output = Rational

The resulting type after applying the ^ operator.

impl ClassifyBrauerWall for Rational

type BrauerWallClass = RationalBrauerWallClass

The Brauer-Wall class datum for this scalar world.

fn bw_class( metric: &Metric<Self>, ) -> Result<RationalBrauerWallClass, ClassifyError>

The Brauer-Wall class of Cl(metric).

impl ClassifyCliffordCenters for Rational

type CenterDiscriminant = RationalMilnorK1Class

Square or Artin–Schreier class controlling the quadratic center.

type CenterBrauerWallClass = RationalBrauerWallClass

The field-specific Brauer–Wall carrier used for the coherence check.

fn clifford_centers( metric: &Metric<Self>, ) -> Result<CliffordCenterInvariants<Self, Self::CenterDiscriminant, Self::CenterBrauerWallClass>, CliffordCenterError>

Construct Z(Cl(q)) and Z(Cl^0(q)) and compare their discriminant class with the existing Brauer–Wall coordinates.

impl ClassifyForm for Rational

type Class = RationalCliffordInvariants

The classification datum produced for this field’s characteristic leg.

fn classify( metric: &Metric<Self>, ) -> Result<RationalCliffordInvariants, ClassifyError>

Classify the form carried by metric.

impl ClassifyIsometry for Rational

fn isometric( m1: &Metric<Self>, m2: &Metric<Self>, ) -> Result<bool, ClassifyError>

Whether two forms over the same scalar world are isometric.

impl ClassifyMilnor for Rational

fn milnor_e1( metric: &Metric<Self>, ) -> Result<Self::K1Class, MilnorInvariantError>

The strict e_1 : I/I^2 -> K^M_1/2 map.

fn milnor_e2( metric: &Metric<Self>, ) -> Result<Self::K2Class, MilnorInvariantError>

The strict e_2 : I^2/I^3 -> K^M_2/2 map.

fn milnor_e0( metric: &Metric<Self>, ) -> Result<MilnorK0Class, MilnorInvariantError>

e_0(q) = dim(q) mod 2.

impl Clone for Rational

fn clone(&self) -> Rational

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rational

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

Formats the value using the given formatter.

impl Display for Rational

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

Formats the value using the given formatter.

impl Eq for Rational

impl ExactFieldScalar for Rational

impl ExactRoots for Rational

fn is_square(&self) -> bool

Whether this element is a square in its world.

fn sqrt(&self) -> Option<Self>

A square root, or None if this is not a square (in the represented subdomain). When there are two roots, the canonical / residue-lifted one.

impl ExactScalar for Rational

impl From<i128> for Rational

fn from(n: i128) -> Self

The ℤ-embedding: the unique unital ring homomorphism ℤ → ℚ.

impl GlobalField for Rational

type Place = Place

A place of the field: ℝ/Q_p for ℚ, or ∞/finite-π for F_q(t).

fn try_relevant_places(entries: &[Self]) -> Option<Vec<Self::Place>>

The places that can carry a nontrivial local condition for entries (every other place sees only units): the archimedean place(s) plus the finite places dividing some entry.

fn try_hilbert_symbol_at( a: &Self, b: &Self, place: &Self::Place, ) -> Option<i128>

The Hilbert symbol (a, b)_v ∈ {+1, −1} over the completion at place.

fn try_is_local_square(x: &Self, place: &Self::Place) -> Option<bool>

Whether a nonzero x is a square in the local field at place.

fn try_is_global_square(x: &Self) -> Option<bool>

Whether a nonzero x is a square in the global field.

fn try_is_isotropic_at_place( entries: &[Self], place: &Self::Place, ) -> Option<bool>

Local isotropy of the nondegenerate diagonal form ⟨a_1,…,a_n⟩ over the completion at place, by rank. The archimedean branch (definiteness) and the finite branch (the Serre rank conditions) live here because the archimedean place exists only over ℚ.

fn try_hasse_at_place(entries: &[Self], place: &Self::Place) -> Option<i128>

The Hasse invariant ε_v(⟨a_1,…,a_n⟩) = ∏_{i<j} (a_i, a_j)_v at place.

fn try_reciprocity_product(a: &Self, b: &Self) -> Option<i128>

The Hilbert reciprocity product ∏_v (a,b)_v over all places — the product formula for the quaternion-algebra class (a,b). It is +1 for every nonzero a, b by Hilbert/Weil reciprocity.

fn try_ramified_places(a: &Self, b: &Self) -> Option<Vec<Self::Place>>

The places where the quaternion algebra (a, b) ramifies (symbol −1). The count is always even — reciprocity, additively.

fn try_is_isotropic_global(entries: &[Self]) -> Option<bool>

Whether ⟨a_1,…,a_n⟩ is isotropic over the global field, by Hasse–Minkowski: isotropic globally iff isotropic at every place. A zero entry is a null direction; rank ≤ 1 is anisotropic; rank 2 needs −a_1a_2 a global square; rank ≥ 3 needs local isotropy at every relevant place.

impl HasRingOfIntegers for Rational

type Int = Integer

The ring of integers, itself a ring whose fraction field is Self.

fn is_integral(&self) -> bool

Whether this element lies in the ring of integers.

fn to_integer(&self) -> Option<Integer>

This element as a ring-of-integers element, or None if it is not integral.

impl Mod2MilnorField for Rational

type K1Class = RationalMilnorK1Class

Carrier of K^M_1(Self)/2.

type K2Class = Brauer2Class

Carrier of K^M_2(Self)/2.

fn supports_mod2_milnor() -> bool

Whether this monomorphization is inside the implemented characteristic-not-two field domain.

fn milnor_symbol_1(a: &Self) -> Option<Self::K1Class>

The degree-one pure symbol {a}. None for a = 0 or when bounded square-class arithmetic leaves the represented domain.

fn milnor_symbol_2(a: &Self, b: &Self) -> Option<Self::K2Class>

The degree-two pure symbol {a,b}. None if either argument is zero or when the exact Brauer calculation leaves the represented domain.

impl Mul for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> Rational

Performs the * operation.

impl Neg for Rational

type Output = Rational

The resulting type after applying the - operator.

fn neg(self) -> Rational

Performs the unary - operation.

impl Ord for Rational

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl Ordered for Rational

fn sign(&self) -> Ordering

Greater / Less / Equal against zero (the sign of the dominant term).

impl PartialEq for Rational

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Rational

fn partial_cmp(&self, other: &Self) -> 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 Scalar for Rational

fn from_int(n: i128) -> Self

Faster direct construction; semantically identical to the default double-and-add.

fn zero() -> Self

The additive identity.

fn one() -> Self

The multiplicative identity.

fn add(&self, rhs: &Self) -> Self

Ring addition.

fn neg(&self) -> Self

Additive inverse.

fn mul(&self, rhs: &Self) -> Self

Ring multiplication.

fn characteristic() -> u128

Ring characteristic: 0 for characteristic-0 domains, a positive additive order of 1 for finite fields and finite quotient rings (Z/p^k, truncated Witt vectors, etc.). The engine itself gets signs from Scalar::neg; callers that care about characteristic must distinguish fields from local rings separately.

fn inv(&self) -> Option<Self>

Multiplicative inverse, or None if not invertible (zero) or not finitely representable in this backend (e.g. a non-monomial surreal, whose inverse is an infinite Hahn series).

fn is_zero(&self) -> bool

Whether this element is the additive identity.

fn sub(&self, rhs: &Self) -> Self

Ring subtraction.

fn pow(&self, exp: u128) -> Self

self^exp by square-and-multiply over Scalar::mul/Scalar::one; x.pow(0) == one(). The same default-method precedent as Scalar::from_int: one correct implementation for every backend whose mul is total, with per-backend overrides only where a genuinely sharper algorithm exists (e.g. Nimber’s Fermat-tower nim_pow, reached through FiniteField::pow).

impl Sub for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> Rational

Performs the - operation.