Struct Real

pub struct Real {
    pub prim: Box<Primitive>,
    pub approx: Option<Approx>,
}

The core idea here is that we represent a real number as a function f(n: i32) -> BigInt, where n is the desired precision (typically negative).

The function is constructed such that |f(n)*2^n - x| < 2^n. By using an increasingly negative n, we can approximate x to arbitrary precision.

Fields

prim: Box<Primitive>

approx: Option<Approx>

Implementations

impl Real

pub fn new(prim: Primitive) -> Self

pub fn known_msd(&self) -> Option<i32>

Returns the most significant digit based on the current approximation. If msd is n, then 2^(n-1) < |x| < 2^(n+1). Returns None if no approximation has been made.

pub fn msd(&mut self, precision: i32) -> Option<i32>

Evaluates to the desired precision and returns the msd. Returns None if the correct msd < precision

pub fn iter_msd_n(&mut self, min_precision: i32) -> Option<i32>

Iteratively lowers the precision until the msd is found, or the provided precision is reached.

pub fn iter_msd(&mut self) -> Option<i32>

Iteratively lowers the precision until the msd is found. This will create an infinite loop if the value is zero.

pub fn appr(&mut self, precision: i32) -> Approx

Generates an approximation of the real number. If we have already approximated the number with a sufficient precision, we simply scale the approximation. Otherwise we call the underlying approximate method.

pub fn render_base(&self, n: u32, base: u32) -> String

pub fn render(&self, n: u32) -> String

pub fn cmp_ra( &mut self, other: &mut Real, rel_tol: i32, abs_tol: i32, ) -> Ordering

pub fn cmp_a(&mut self, other: &mut Real, abs_tol: i32) -> Ordering

pub fn cmp_until(&self, other: &Real, min_precision: i32) -> Ordering

pub fn signum_a(&self, a: i32) -> i32

impl Real

pub fn int(value: BigInt) -> Self

pub fn squared(self) -> Self

pub fn atan(value: BigInt) -> Self

pub fn exp(self) -> Self

pub fn cos(self) -> Self

pub fn sin(self) -> Self

pub fn asin(self) -> Self

pub fn acos(self) -> Self

pub fn ln2(self) -> Self

pub fn ln(self) -> Self

pub fn sqrt(self) -> Self

pub fn shifted(self, bits: i32) -> Self

pub fn pi() -> Self

John Machin’s formula from 1706: pi/4 = 4 * atan(1/5) - atan(1/239)

pub fn inv(self) -> Self

Trait Implementations

impl Add for Real

type Output = Real

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Real

fn clone(&self) -> Real

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Real

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

Formats the value using the given formatter.

impl Div for Real

type Output = Real

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl From<BigInt> for Real

fn from(value: BigInt) -> Self

Converts to this type from the input type.

impl From<Ratio<BigInt>> for Real

fn from(value: BigRational) -> Self

Converts to this type from the input type.

impl From<f64> for Real

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Real

fn from(value: i32) -> Self

Converts to this type from the input type.

impl FromStr for Real

type Err = ParseBigIntError

The associated error which can be returned from parsing.

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Into<BigInt> for Real

fn into(self) -> BigInt

Converts this type into the (usually inferred) input type.

impl Into<f64> for Real

fn into(self) -> f64

Converts this type into the (usually inferred) input type.

impl Mul for Real

type Output = Real

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Real

type Output = Real

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Num for Real

type FromStrRadixErr = ParseBigIntError

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl One for Real

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl Ord for Real

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 PartialEq for Real

fn eq(&self, other: &Self) -> 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 PartialOrd for Real

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 Rem for Real

type Output = Real

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self

Performs the % operation.

impl Signed for Real

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl Sub for Real

type Output = Real

The resulting type after applying the - operator.

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

Performs the - operation.

impl Zero for Real

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Eq for Real