Crate arpfloat

ARPFloat is an implementation of arbitrary precision floating point data structures and utilities. The library can be used to emulate existing floating point types, such as FP16, and create new floating point types. Floating point types can scale to hundreds of digits, and perform very accurate calculations. In ARPFloat the rounding mode is a part of the type-system, and this defines away a number of problem that show up when using fenv.h.

Example

  use arpfloat::Float;
  use arpfloat::FP128;

  // Create the number '5' in FP128 format.
  let n = Float::from_f64(5.).cast(FP128);

  // Use Newton-Raphson to find the square root of 5.
  let mut x = n.clone();
  for _ in 0..20 {
      x += (&n / &x)/2;
  }

  println!("fp128: {}", x);
  println!("fp64:  {}", x.as_f64());

The program above will print this output:

fp128: 2.2360679774997896964091736687312763
fp64:  2.23606797749979

The library also provides API that exposes rounding modes, and low-level operations.

    use arpfloat::FP128;
    use arpfloat::RoundingMode::NearestTiesToEven;
    use arpfloat::Float;

    let x = Float::from_u64(FP128, 1<<53);
    let y = Float::from_f64(1000.0).cast(FP128);

    let val = Float::mul_with_rm(&x, &y, NearestTiesToEven);

View the internal representation of floating point numbers:

   use arpfloat::Float;
   use arpfloat::FP16;

   let fp = Float::from_i64(FP16, 15);

   fp.dump(); // Prints FP[+ E=+3 M=11110000000]

   let m = fp.get_mantissa();
   m.dump(); // Prints 11110000000

Control the rounding mode for type conversion:

    use arpfloat::{FP16, FP32, RoundingMode, Float};

    let x = Float::from_u64(FP32, 2649);              // Load an FP32 Value.
    let b = x.cast_with_rm(FP16, RoundingMode::Zero); // Convert to FP16.
    println!("{}", b);                                // Prints 2648!

Define new float formats and use high-precision transcendental functions:

  use arpfloat::{Float, Semantics, RoundingMode};
  // Define a new float format with 120 bits of accuracy, and dynamic range
  // of 2^10.
  let sem = Semantics::new(10, 120, RoundingMode::NearestTiesToEven);

  let pi = Float::pi(sem);
  let x = Float::exp(&pi);
  println!("e^pi = {}", x); // Prints 23.1406926327792....

Structs

Float

This is the main data structure of this library. It represents an arbitrary-precision floating-point number.

Semantics

Controls the semantics of a floating point number using two fields: ‘precision’, that determines the number of bits, and ‘exponent’ that controls the dynamic range of the number.

Enums

RoundingMode

Defines the supported rounding modes. See IEEE754-2019 Section 4.3 Rounding-direction attributes

Constants

FP16

Predefined FP16 float with 5 exponent bits, and 10 mantissa bits.

FP32

Predefined FP32 float with 8 exponent bits, and 23 mantissa bits.

FP64

Predefined FP64 float with 11 exponent bits, and 52 mantissa bits.

FP128

Predefined FP128 float with 15 exponent bits, and 112 mantissa bits.

FP256

Predefined FP256 float with 19 exponent bits, and 236 mantissa bits.