dashu-float

Arbitrary precision floating point number implementation as a part of the dashu library. See Docs.rs for the full documentation.

Features

• Supports no_std and written in pure Rust.
• Support arbitrary base and arbitrary rounding mode.
• Support efficient base conversion.
• Small float numbers are inlined on stack.
• Efficient float number parsing and printing with base 2~36.
• Supports the hexadecimal float format used by C++.
• Developer friendly debug printing for float numbers.

Optional dependencies

• std (default): enable std support for dependencies.

Performance

Relevant benchmark will be implemented in the built-in benchmark.

License

See the top-level readme.

lib.rs:

A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode.

The library implements efficient large floating point arithmetic in pure Rust.

The main type is [FBig] representing the arbitrary precision floating point numbers, the [DBig] type is an alias supporting decimal floating point numbers.

To construct big floats from literals, please use the dashu-macro crate for your convenience.

Examples

# use dashu_base::ParseError;
use core::convert::TryFrom;
use dashu_float::DBig;

// due to the limit of rust generics, the default float type
// need to be instantiate explicitly
type FBig = dashu_float::FBig;

let a = FBig::try_from(-12.34_f32).unwrap();
let b = DBig::from_str_native("6.022e23")?;
let c = DBig::from_parts(271828.into(), -5);
let d: DBig = "-0.0123456789".parse()?;
let e = 2 * b.ln() + DBig::ONE;
let f = &c * d.powi(10.into()) / 7;

assert_eq!(a.precision(), 24); // IEEE 754 single has 24 significant bits
assert_eq!(b.precision(), 4); // 4 decimal digits

assert!(b > c); // comparison is limited in the same base
assert!(a.to_decimal().value() < d);
assert_eq!(c.to_string(), "2.71828");

// use associated functions of the context to get full result
use dashu_base::Approximation::*;
use dashu_float::{Context, round::{mode::HalfAway, Rounding::*}};
let ctxt = Context::<HalfAway>::new(6);
assert_eq!(ctxt.exp(DBig::ONE.repr()), Inexact(c, NoOp));
# Ok::<(), ParseError>(())

Optional dependencies

• std (default): enable std for dependencies.