#float #ord #na-n #finite #panic

noisy_float

Contains floating point types that panic if they are set to an illegal value, such as NaN

17 releases

0.2.0 Mar 27, 2021
0.1.14 Feb 21, 2021
0.1.13 Sep 6, 2020
0.1.12 Dec 21, 2019
0.1.2 Sep 12, 2016

#42 in Math

Download history 1889/week @ 2021-06-25 1629/week @ 2021-07-02 2808/week @ 2021-07-09 2160/week @ 2021-07-16 3177/week @ 2021-07-23 3335/week @ 2021-07-30 2827/week @ 2021-08-06 2274/week @ 2021-08-13 3083/week @ 2021-08-20 2692/week @ 2021-08-27 2385/week @ 2021-09-03 3450/week @ 2021-09-10 2264/week @ 2021-09-17 2885/week @ 2021-09-24 3092/week @ 2021-10-01 3518/week @ 2021-10-08

7,557 downloads per month
Used in 53 crates (30 directly)

Apache-2.0

54KB
1.5K SLoC

noisy_float-rs

This is a Rust library containing floating point types that panic if they are set to an illegal value, such as NaN.

Crate

The Rust crate for this library can be found here.

Documentation

The documentation for this library can be found here.

Description

The name "Noisy Float" comes from the terms "quiet NaN" and "signaling NaN"; "signaling" was too long to put in a struct/crate name, so "noisy" is used instead, being the opposite of "quiet."

The standard types defined in noisy_float::types follow the principle demonstrated by Rust's handling of integer overflow: a bad arithmetic operation is considered an error, but it is too costly to check everywhere in optimized builds. For each floating point number that is created, a debug_assert! invocation is used to check if it is valid or not. This way, there are guarantees when developing code that floating point numbers have valid values, but during a release run there is no overhead for using these floating point types compared to using f32 or f64 directly.

This crate makes use of the num, bounded, signed and floating point traits in the popular num_traits crate. This crate can be compiled with no_std.

Examples

An example using the R64 type, which corresponds to finite f64 values.

use noisy_float::prelude::*;

fn geometric_mean(a: R64, b: R64) -> R64 {
    (a * b).sqrt() //used just like regular floating-point numbers
}

println!("geometric_mean(10.0, 20.0) = {}", geometric_mean(r64(10.0), r64(20.0)));
//prints 14.142...

An example using the N32 type, which corresponds to non-NaN f32 values. The float types in this crate are able to implement Eq and Ord properly, since NaN is not allowed.

use noisy_float::prelude::*;

let values = vec![n32(3.0), n32(-1.5), n32(71.3), N32::infinity()];
assert!(values.iter().cloned().min() == Some(n32(-1.5)));
assert!(values.iter().cloned().max() == Some(N32::infinity()));

License

Noisy_float is licensed under the Apache 2.0 License.

Dependencies

~215KB