Struct Hypernatural 

pub struct Hypernatural { /* private fields */ }

An integer polynomial in the generator, by residue class. See the module documentation.

Implementations

impl Hypernatural

pub fn generator(ty: &ResidueType) -> Hypernatural

H itself.

pub fn from_integer(n: BigInt, ty: &ResidueType) -> Hypernatural

A standard integer.

pub fn from_polynomial(p: Poly, ty: &ResidueType) -> Option<Hypernatural>

The polynomial p in H as an infinite integer, when it is an integer on every class the type admits: a polynomial of degree d that is an integer at d + 1 consecutive integers is one at every integer, and likewise along one residue class.

pub fn from_branches(value: Depends<Poly>) -> Option<Hypernatural>

The value p on each class, when each p is an integer on the admitted members of its class.

pub fn floor_of( x: &Hyperreal, ty: &ResidueType, ) -> Result<Hypernatural, FloorError>

⌊x⌋ for a hyperreal x under the residue type ty. With x = P(H) + r — P its principal part with rational coefficients, r limited — and D the common denominator of P, the fractional part of P(H) is (D·P(H) mod D)/D on each class, so ⌊x⌋ = P(H) − frac + ⌊frac + r⌋ there.

pub fn ceil_of( x: &Hyperreal, ty: &ResidueType, ) -> Result<Hypernatural, FloorError>

⌈x⌉ = −⌊−x⌋.

pub fn depends(&self) -> &Depends<Poly>

pub fn add(&self, o: &Hypernatural) -> Result<Hypernatural, ResidueError>

pub fn sub(&self, o: &Hypernatural) -> Result<Hypernatural, ResidueError>

pub fn mul(&self, o: &Hypernatural) -> Result<Hypernatural, ResidueError>

pub fn degree(&self) -> usize

The highest degree in H over every class.

pub fn pow(&self, k: u64) -> Result<Hypernatural, PowerError>

self^k by repeated squaring, refused when its degree would pass MAX_POWER_DEGREE.

pub fn neg(&self) -> Hypernatural

pub fn rem(&self, k: &BigInt) -> Result<Depends<BigInt>, ResidueError>

self mod k (in 0..k) on every residue class of H; refused when reading it needs more than MAX_MODULUS classes.

pub fn scaled_floor(&self, t: &Rational) -> Result<Hypernatural, ResidueError>

⌊t·self⌋ for a rational t.

pub fn scaled_ceil(&self, t: &Rational) -> Result<Hypernatural, ResidueError>

⌈t·self⌉ = −⌊−t·self⌋.

pub fn compare( &self, o: &Hypernatural, ) -> Result<Depends<Ordering>, ResidueError>

The order against another value on every class (H exceeds every standard natural, so the leading coefficient of the difference decides).

pub fn is_infinite(&self) -> Depends<bool>

pub fn is_negative(&self) -> Depends<bool>

pub fn eval_at(&self, h: u64) -> Option<BigInt>

The value at the standard point H = h, when the type admits it.

pub fn to_hyperreal(&self) -> Depends<Hyperreal>

H ↦ 1/dt.

pub fn render(&self, generator: &str) -> String

The value as a polynomial in generator, with its dependence on the residue when there is one.

pub fn render_reciprocal(&self, inf: &str) -> String

The value written in the infinitesimal dt = 1/H: 2/dt + 1.

Trait Implementations

impl Clone for Hypernatural

fn clone(&self) -> Hypernatural

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hypernatural

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

Formats the value using the given formatter.

impl ExactCodec for Hypernatural

fn write(&self, out: &mut Vec<u8>)

The residue-indexed polynomials in the generator.

fn read(buf: &[u8], pos: &mut usize) -> Option<Self>

Refused unless every branch is integer-valued on the admitted members of its class: a polynomial of degree d that is an integer at d + 1 consecutive members of an arithmetic progression is one at every member.

fn to_bytes(&self) -> Vec<u8>

fn from_bytes(buf: &[u8]) -> Option<Self>

The value buf canonically encodes, with nothing left over.

impl Hash for Hypernatural

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Hypernatural

fn eq(&self, other: &Hypernatural) -> 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 Eq for Hypernatural

impl StructuralPartialEq for Hypernatural