#floating-point #decimal-number #big-decimal #decimal #arbitrary-precision

no-std dashu-float

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

9 releases

0.4.3 Feb 3, 2024
0.4.1 Dec 17, 2023
0.4.0 Sep 12, 2023
0.3.2 Mar 4, 2023
0.3.0 Nov 10, 2022

#604 in Math

Download history 572/week @ 2024-03-13 594/week @ 2024-03-20 598/week @ 2024-03-27 1027/week @ 2024-04-03 990/week @ 2024-04-10 763/week @ 2024-04-17 705/week @ 2024-04-24 801/week @ 2024-05-01 276/week @ 2024-05-08 351/week @ 2024-05-15 330/week @ 2024-05-22 343/week @ 2024-05-29 311/week @ 2024-06-05 339/week @ 2024-06-12 451/week @ 2024-06-19 246/week @ 2024-06-26

1,401 downloads per month
Used in 19 crates (4 directly)

MIT/Apache

1MB
20K 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 core::str::FromStr;
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("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));

Optional dependencies

  • std (default): enable std for dependencies.

Dependencies

~0.3–1.8MB
~39K SLoC