#ecmascript #javascript #string #ryu

ryu-ecmascript

Fast floating point to string conversion, suitable for ECMAScript NumberToString

2 releases

Uses old Rust 2015

0.1.1 Oct 31, 2018
0.1.0 Oct 2, 2018
Download history 470/week @ 2021-06-07 440/week @ 2021-06-14 325/week @ 2021-06-21 426/week @ 2021-06-28 353/week @ 2021-07-05 348/week @ 2021-07-12 287/week @ 2021-07-19 403/week @ 2021-07-26 296/week @ 2021-08-02 280/week @ 2021-08-09 275/week @ 2021-08-16 326/week @ 2021-08-23 282/week @ 2021-08-30 284/week @ 2021-09-06 399/week @ 2021-09-13 362/week @ 2021-09-20

1,607 downloads per month
Used in 10 crates (3 directly)

Apache-2.0 OR BSL-1.0

135KB
2K SLoC

ECMAScript Number.toString Ryū

Fork of the ryu crate, with the safe API changed to implement the formatting rules specified in ECMAScript 2015 ToString Applied to the Number Type. It applies NOTE 2 to the algorithm and uses round-to-even to determine whether s * (10 ^ (n - k)) is m.

Original README (minus badges) below.


Pure Rust implementation of Ryū, an algorithm to quickly convert floating point numbers to decimal strings.

The PLDI'18 paper Ryū: fast float-to-string conversion by Ulf Adams includes a complete correctness proof of the algorithm. The paper is available under the creative commons CC-BY-SA license.

This Rust implementation is a line-by-line port of Ulf Adams' implementation in C, https://github.com/ulfjack/ryu. The ryu::raw module exposes exactly the API and formatting of the C implementation as unsafe pure Rust functions. There is additionally a safe API as demonstrated in the example code below. The safe API uses the same underlying Ryū algorithm but diverges from the formatting of the C implementation to produce more human-readable output, for example 0.3 rather than 3E-1.

Requirements: this crate supports any compiler version back to rustc 1.15; it uses nothing from the Rust standard library so is usable from no_std crates.

[dependencies]
ryu = "0.2"

Examples

extern crate ryu;

fn main() {
    let mut buffer = ryu::Buffer::new();
    let printed = buffer.format(1.234);
    assert_eq!(printed, "1.234");
}

Performance

You can run upstream's benchmarks with:

$ git clone https://github.com/ulfjack/ryu c-ryu
$ cd c-ryu
$ bazel run -c opt //ryu/benchmark

And our benchmarks with:

$ git clone https://github.com/ulfjack/ryu rust-ryu
$ cd rust-ryu
$ cargo run --example benchmark --release

These benchmarks measure the average time to print a 32-bit float and average time to print a 64-bit float, where the inputs are distributed as uniform random bit patterns 32 and 64 bits wide.

The upstream C code, the unsafe direct Rust port, and the safe pretty Rust API all perform the same, taking around 21 nanoseconds to format a 32-bit float and 31 nanoseconds to format a 64-bit float.

License

Licensed under either of the following at your option.

Dependencies

~115KB