Struct arpfloat::Float

pub struct Float<const EXPONENT: usize, const MANTISSA: usize> { /* private fields */ }

This is the main data structure of this library. It represents an arbitrary-precision floating-point number. The data structure is generic and accepts the EXPONENT and MANTISSA constants, that represent the encoding number of bits that are dedicated to storing these values.

Implementations

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn add_with_rm(a: Self, b: Self, rm: RoundingMode) -> Self

Computes a+b using the rounding mode rm.

pub fn sub_with_rm(a: Self, b: Self, rm: RoundingMode) -> Self

Computes a-b using the rounding mode rm.

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn mul_with_rm(a: Self, b: Self, rm: RoundingMode) -> Self

Compute a*b using the rounding mode rm.

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn div_with_rm(a: Self, b: Self, rm: RoundingMode) -> Self

Compute a/b, with the rounding mode rm.

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn from_u64(val: u64) -> Self

Load the integer val into the float. Notice that the number may overflow, or rounded to the nearest even integer.

Examples found in repository

examples/calc_pi.rs (line 11)

fn main() {
    // https://en.wikipedia.org/wiki/Chudnovsky_algorithm
    let iterations = 5;

    // Constants:
    let c1 = FP::from_u64(10005).sqrt();
    let c2 = FP::from_u64(545140134);
    let c3 = FP::from_i64(-262537412640768000);
    let c16 = FP::from_u64(16);
    let c12 = FP::from_u64(12);

    // Initial state.
    let mut kc = FP::from_u64(6);
    let mut m = FP::from_u64(1);
    let mut l = FP::from_u64(13591409);
    let mut x = FP::from_u64(1);
    let mut s = FP::from_u64(13591409);

    for q in 1..iterations + 1 {
        let q3 = FP::from_u64(q * q * q);
        let k3 = kc * kc * kc;
        m = (k3 - (kc * c16)) * m / q3;
        l = l + c2;
        x = x * c3;
        s = s + (m * l / x);
        kc = kc + c12;
    }
    let pi = FP::from_u64(426880) * (c1 / s);
    println!("pi = {}", pi);
    assert_eq!(pi.as_f64(), std::f64::consts::PI);
}

pub fn from_i64(val: i64) -> Self

Load the integer val into the float. Notice that the number may overflow, or rounded to the nearest even integer.

Examples found in repository

examples/calc_pi.rs (line 13)

fn main() {
    // https://en.wikipedia.org/wiki/Chudnovsky_algorithm
    let iterations = 5;

    // Constants:
    let c1 = FP::from_u64(10005).sqrt();
    let c2 = FP::from_u64(545140134);
    let c3 = FP::from_i64(-262537412640768000);
    let c16 = FP::from_u64(16);
    let c12 = FP::from_u64(12);

    // Initial state.
    let mut kc = FP::from_u64(6);
    let mut m = FP::from_u64(1);
    let mut l = FP::from_u64(13591409);
    let mut x = FP::from_u64(1);
    let mut s = FP::from_u64(13591409);

    for q in 1..iterations + 1 {
        let q3 = FP::from_u64(q * q * q);
        let k3 = kc * kc * kc;
        m = (k3 - (kc * c16)) * m / q3;
        l = l + c2;
        x = x * c3;
        s = s + (m * l / x);
        kc = kc + c12;
    }
    let pi = FP::from_u64(426880) * (c1 / s);
    println!("pi = {}", pi);
    assert_eq!(pi.as_f64(), std::f64::consts::PI);
}

pub fn to_i64(&self, rm: RoundingMode) -> i64

Converts and returns the rounded integral part.

pub fn trunc(&self) -> Self

Returns a value that is rounded to the nearest integer that’s not larger in magnitude than this float.

pub fn cast_with_rm<const E: usize, const M: usize>(
    &self,
    rm: RoundingMode
) -> Float<E, M>

Cast to another float using the rounding mode rm.

pub fn cast<const E: usize, const M: usize>(&self) -> Float<E, M>

Convert from one float format to another.

pub fn as_f32(&self) -> f32

pub fn as_f64(&self) -> f64

Examples found in repository

examples/calc_pi.rs (line 35)

fn main() {
    // https://en.wikipedia.org/wiki/Chudnovsky_algorithm
    let iterations = 5;

    // Constants:
    let c1 = FP::from_u64(10005).sqrt();
    let c2 = FP::from_u64(545140134);
    let c3 = FP::from_i64(-262537412640768000);
    let c16 = FP::from_u64(16);
    let c12 = FP::from_u64(12);

    // Initial state.
    let mut kc = FP::from_u64(6);
    let mut m = FP::from_u64(1);
    let mut l = FP::from_u64(13591409);
    let mut x = FP::from_u64(1);
    let mut s = FP::from_u64(13591409);

    for q in 1..iterations + 1 {
        let q3 = FP::from_u64(q * q * q);
        let k3 = kc * kc * kc;
        m = (k3 - (kc * c16)) * m / q3;
        l = l + c2;
        x = x * c3;
        s = s + (m * l / x);
        kc = kc + c12;
    }
    let pi = FP::from_u64(426880) * (c1 / s);
    println!("pi = {}", pi);
    assert_eq!(pi.as_f64(), std::f64::consts::PI);
}

pub fn from_f32(float: f32) -> Self

pub fn from_f64(float: f64) -> Self

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn new(sign: bool, exp: i64, mantissa: BigInt<8>) -> Self

Create a new normal floating point number.

pub fn raw(sign: bool, exp: i64, mantissa: BigInt<8>, category: Category) -> Self

Create a new normal floating point number.

pub fn zero(sign: bool) -> Self

Returns a new zero float.

pub fn inf(sign: bool) -> Self

Returns a new infinity float.

pub fn nan(sign: bool) -> Self

Returns a new NaN float.

pub fn is_negative(&self) -> bool

Returns true if the Float is negative

pub fn is_inf(&self) -> bool

Returns true if the Float is +-inf.

pub fn is_nan(&self) -> bool

Returns true if the Float is a +- NaN.

pub fn is_zero(&self) -> bool

Returns true if the Float is a +- NaN.

pub fn is_normal(&self) -> bool

Returns true if this number is normal (not Zero, Nan, Inf).

pub fn set_sign(&mut self, sign: bool)

Update the sign of the float to sign. True means negative.

pub fn get_sign(&self) -> bool

Returns the sign of the float. True means negative.

pub fn get_mantissa(&self) -> BigInt<8>

Returns the mantissa of the float.

pub fn get_exp(&self) -> i64

Returns the exponent of the float.

pub fn get_category(&self) -> Category

Returns the category of the float.

pub fn neg(&self) -> Self

Returns a new float which has a flipped sign (negated value).

pub fn dump(&self)

Prints the number using the internal representation.

pub fn get_exp_bounds() -> (i64, i64)

Returns the upper and lower bounds of the exponent.

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn sqrt(&self) -> Self

Calculate the square root of the number using the Newton Raphson

Examples found in repository

examples/calc_pi.rs (line 11)

fn main() {
    // https://en.wikipedia.org/wiki/Chudnovsky_algorithm
    let iterations = 5;

    // Constants:
    let c1 = FP::from_u64(10005).sqrt();
    let c2 = FP::from_u64(545140134);
    let c3 = FP::from_i64(-262537412640768000);
    let c16 = FP::from_u64(16);
    let c12 = FP::from_u64(12);

    // Initial state.
    let mut kc = FP::from_u64(6);
    let mut m = FP::from_u64(1);
    let mut l = FP::from_u64(13591409);
    let mut x = FP::from_u64(1);
    let mut s = FP::from_u64(13591409);

    for q in 1..iterations + 1 {
        let q3 = FP::from_u64(q * q * q);
        let k3 = kc * kc * kc;
        m = (k3 - (kc * c16)) * m / q3;
        l = l + c2;
        x = x * c3;
        s = s + (m * l / x);
        kc = kc + c12;
    }
    let pi = FP::from_u64(426880) * (c1 / s);
    println!("pi = {}", pi);
    assert_eq!(pi.as_f64(), std::f64::consts::PI);
}

pub fn abs(&self) -> Self

Returns the absolute value of this float.

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

Returns the greater of self and other.

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

Returns the smaller of self and other.

impl<const EXPONENT: usize, const MANTISSA: usize> Float<EXPONENT, MANTISSA>

pub fn get_decimal_accuracy() -> usize

Returns the highest number of decimal digits that are needed for representing this type accurately.

Trait Implementations

impl<const EXPONENT: usize, const MANTISSA: usize> Add<Float<EXPONENT, MANTISSA>> for Float<EXPONENT, MANTISSA>

type Output = Float<EXPONENT, MANTISSA>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const EXPONENT: usize, const MANTISSA: usize> Clone for Float<EXPONENT, MANTISSA>

fn clone(&self) -> Float<EXPONENT, MANTISSA>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const EXPONENT: usize, const MANTISSA: usize> Debug for Float<EXPONENT, MANTISSA>

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

Formats the value using the given formatter.

impl<const EXPONENT: usize, const MANTISSA: usize> Display for Float<EXPONENT, MANTISSA>

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

Formats the value using the given formatter.

impl<const EXPONENT: usize, const MANTISSA: usize> Div<Float<EXPONENT, MANTISSA>> for Float<EXPONENT, MANTISSA>

type Output = Float<EXPONENT, MANTISSA>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const EXPONENT: usize, const MANTISSA: usize> Mul<Float<EXPONENT, MANTISSA>> for Float<EXPONENT, MANTISSA>

type Output = Float<EXPONENT, MANTISSA>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const EXPONENT: usize, const MANTISSA: usize> PartialEq<Float<EXPONENT, MANTISSA>> for Float<EXPONENT, MANTISSA>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<const EXPONENT: usize, const MANTISSA: usize> PartialOrd<Float<EXPONENT, MANTISSA>> for Float<EXPONENT, MANTISSA>

Page 66. Chapter 3. Floating-Point Formats and Environment Table 3.8: Comparison predicates and the four relations. and IEEE 754-2019 section 5.10 - totalOrder.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const EXPONENT: usize, const MANTISSA: usize> Sub<Float<EXPONENT, MANTISSA>> for Float<EXPONENT, MANTISSA>

type Output = Float<EXPONENT, MANTISSA>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const EXPONENT: usize, const MANTISSA: usize> Copy for Float<EXPONENT, MANTISSA>