#mathematics #numerics #rational #arbitrary-precision #bigrat

no-std dashu-ratio

A big rational library with good performance

3 releases

0.3.2 Mar 13, 2023
0.3.1 Dec 8, 2022
0.3.0 Nov 10, 2022

#780 in Math

Download history 170/week @ 2022-11-29 223/week @ 2022-12-06 284/week @ 2022-12-13 466/week @ 2022-12-20 123/week @ 2022-12-27 521/week @ 2023-01-03 516/week @ 2023-01-10 457/week @ 2023-01-17 493/week @ 2023-01-24 510/week @ 2023-01-31 563/week @ 2023-02-07 536/week @ 2023-02-14 612/week @ 2023-02-21 562/week @ 2023-02-28 550/week @ 2023-03-07 591/week @ 2023-03-14

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

MIT/Apache

1MB
22K SLoC

dashu-ratio

Arbitrary precision rational 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 a relaxed verion of rational numbers for fast computation.
  • Support for Diophantine Approximation of floating point numbers.
  • Rational numbers with small numerators and denominators are inlined on stack.
  • Efficient integer parsing and printing with base 2~36.
  • 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 rational library with good performance.

The library implements efficient arithmetic and conversion functions in pure Rust.

The two main rational types are [RBig] and [Relaxed]. Both of them represent the rational number as a pair of integers (numerator and denominator) and their APIs are mostly the same. However only with [RBig], the numerator and denominator are reduced so that they don't have common divisors other than one. Therefore, [Relaxed] can be much faster if you don't care about a reduced representation of the rational number.

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

Examples

# use dashu_base::ParseError;
use dashu_int::{IBig, UBig};
use dashu_ratio::{RBig, Relaxed};

let a = RBig::from_parts((-12).into(), 34u8.into());
let b = RBig::from_str_radix("-azz/ep", 36).unwrap();
let c = RBig::try_from(3.1415926f32).unwrap(); // c = 6588397 / 2097152 (lossless)
let c2 = RBig::simplest_from_f32(3.1415926).unwrap(); // c2 = 51808 / 16491
assert_eq!(c2.numerator(), &IBig::from(51808));

assert_eq!(c.to_string(), "6588397/2097152");
let d = RBig::simplest_from_f32(22./7.).unwrap();
assert_eq!(d.to_string(), "22/7"); // round trip to the original literal

// for Relaxed, only the common divisor 2 is removed
let e: Relaxed = "-3228/1224".parse()?; // d = -807 / 306
assert_eq!(e.numerator(), &IBig::from(-807));
let f: RBig = e.clone().canonicalize(); // e = -269 / 102
assert_eq!(f.numerator(), &IBig::from(-269));

// comparison is allowed between RBig and Relaxed
assert_eq!(e, f);
# Ok::<(), ParseError>(())

Dependencies

~400–580KB