Struct dashu_float::Repr

pub struct Repr<const BASE: Word> { /* private fields */ }

Underlying representation of an arbitrary precision floating number.

The floating point number is represented as significand * base^exponent, where the type of the significand is IBig, and the type of exponent is isize. The representation is always normalized (nonzero signficand is not divisible by the base, or zero signficand with zero exponent).

When it’s used together with a Context, its precision will be limited so that |signficand| < base^precision. However, the precision limit is not always enforced. In rare cases, the significand can have one more digit than the precision limit.

Infinity

This struct supports representing the infinity, but the infinity is only supposed to be used as sentinels. That is, only equality test and comparison are implemented for the infinity. Any other operations on the infinity will lead to panic. If an operation result is too large or too small, the operation will panic instead of returning an infinity.

Implementations

impl<const B: Word> Repr<B>

pub const BASE: IBig = _

The base of the representation. It’s exposed as an IBig constant.

pub const fn zero() -> Self

Create a Repr instance representing value zero

pub const fn one() -> Self

Create a Repr instance representing value one

pub const fn neg_one() -> Self

Create a Repr instance representing value negative one

pub const fn infinity() -> Self

Create a Repr instance representing the (positive) infinity

pub const fn neg_infinity() -> Self

Create a Repr instance representing the negative infinity

pub const fn is_zero(&self) -> bool

Determine if the Repr represents zero

Examples

assert!(Repr::<2>::zero().is_zero());
assert!(!Repr::<10>::one().is_zero());

pub const fn is_one(&self) -> bool

Determine if the Repr represents one

Examples

assert!(Repr::<2>::zero().is_zero());
assert!(!Repr::<10>::one().is_zero());

pub const fn is_infinite(&self) -> bool

Determine if the Repr represents the (±)infinity

Examples

assert!(Repr::<2>::infinity().is_infinite());
assert!(Repr::<10>::neg_infinity().is_infinite());
assert!(!Repr::<10>::one().is_infinite());

pub const fn is_finite(&self) -> bool

Determine if the Repr represents a finite number

Examples

assert!(Repr::<2>::zero().is_finite());
assert!(Repr::<10>::one().is_finite());
assert!(!Repr::<16>::infinity().is_finite());

pub const fn sign(&self) -> Sign

Get the sign of the number

Examples

assert_eq!(Repr::<2>::zero().sign(), Sign::Positive);
assert_eq!(Repr::<2>::neg_one().sign(), Sign::Negative);
assert_eq!(Repr::<10>::neg_infinity().sign(), Sign::Negative);

pub fn digits(&self) -> usize

Get the number of digits (under base B) in the significand.

If the number is 0, then 0 is returned (instead of 1).

Examples

assert_eq!(Repr::<2>::zero().digits(), 0);
assert_eq!(Repr::<2>::one().digits(), 1);
assert_eq!(Repr::<10>::one().digits(), 1);

assert_eq!(Repr::<10>::new(100.into(), 0).digits(), 1); // 1e2
assert_eq!(Repr::<10>::new(101.into(), 0).digits(), 3);

pub fn digits_ub(&self) -> usize

Fast over-estimation of digits

Examples

assert_eq!(Repr::<2>::zero().digits_ub(), 0);
assert_eq!(Repr::<2>::one().digits_ub(), 1);
assert_eq!(Repr::<10>::one().digits_ub(), 1);
assert_eq!(Repr::<2>::new(31.into(), 0).digits_ub(), 5);
assert_eq!(Repr::<10>::new(99.into(), 0).digits_ub(), 2);

pub fn digits_lb(&self) -> usize

Fast under-estimation of digits

Examples

assert_eq!(Repr::<2>::zero().digits_lb(), 0);
assert_eq!(Repr::<2>::one().digits_lb(), 0);
assert_eq!(Repr::<10>::one().digits_lb(), 0);
assert_eq!(Repr::<10>::new(1001.into(), 0).digits_lb(), 3);

pub fn new(significand: IBig, exponent: isize) -> Self

Create a Repr from the significand and exponent. This constructor will normalize the representation.

Examples

let a = Repr::<2>::new(400.into(), -2);
assert_eq!(a.significand(), &25);
assert_eq!(a.exponent(), 2);

let b = Repr::<10>::new(400.into(), -2);
assert_eq!(b.significand(), &4);
assert_eq!(b.exponent(), 0);

pub fn significand(&self) -> &IBig

Get the significand of the representation

pub fn exponent(&self) -> isize

Get the exponent of the representation

pub fn into_parts(self) -> (IBig, isize)

Convert the float number into raw (signficand, exponent) parts

Examples

use dashu_int::IBig;

let a = Repr::<2>::new(400.into(), -2);
assert_eq!(a.into_parts(), (IBig::from(25), 2));

let b = Repr::<10>::new(400.into(), -2);
assert_eq!(b.into_parts(), (IBig::from(4), 0));

Trait Implementations

impl<const B: Word> Clone for Repr<B>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const B: Word> Debug for Repr<B>

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

Formats the value using the given formatter.

impl<const B: Word> Display for Repr<B>

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

Formats the value using the given formatter.

impl<const B: Word> EstimatedLog2 for Repr<B>

fn log2_bounds(&self) -> (f32, f32)

Estimate the bounds of the binary logarithm.

fn log2_est(&self) -> f32

Estimate the value of the binary logarithm. It’s calculated as the average of log2_bounds by default.

impl<const B: Word> Neg for Repr<B>

type Output = Repr<B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const B: Word> Ord for Repr<B>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl<const BASE: Word> PartialEq<Repr<BASE>> for Repr<BASE>

fn eq(&self, other: &Repr<BASE>) -> bool

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

const 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 B: Word> PartialOrd<Repr<B>> for Repr<B>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

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

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

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

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

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

const 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 BASE: Word> Eq for Repr<BASE>

impl<const BASE: Word> StructuralEq for Repr<BASE>

impl<const BASE: Word> StructuralPartialEq for Repr<BASE>