#mathematics #numerics #floating-point #decimal #arbitrary-precision

no-std dashu-float

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

5 releases

0.3.2 Mar 4, 2023
0.3.1 Dec 8, 2022
0.3.0 Nov 10, 2022
0.2.1 Oct 21, 2022
0.2.0 Sep 13, 2022

#181 in Math

Download history 207/week @ 2022-12-03 302/week @ 2022-12-10 469/week @ 2022-12-17 87/week @ 2022-12-24 542/week @ 2022-12-31 507/week @ 2023-01-07 447/week @ 2023-01-14 517/week @ 2023-01-21 542/week @ 2023-01-28 585/week @ 2023-02-04 520/week @ 2023-02-11 630/week @ 2023-02-18 591/week @ 2023-02-25 597/week @ 2023-03-04 575/week @ 2023-03-11 635/week @ 2023-03-18

2,537 downloads per month
Used in 6 crates (4 directly)

MIT/Apache

1MB
19K SLoC

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.

Dependencies

~400–580KB