#high-precision #fixed-point #arithmetic-operations #deterministic #numbers #angle #calculations

i_float

This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations

25 releases (14 stable)

new 1.5.1 Nov 21, 2024
1.3.1 Sep 19, 2024
1.2.3 Jul 24, 2024
0.10.0 Apr 18, 2024
0.2.0 Nov 12, 2023

#202 in Rust patterns

Download history 46/week @ 2024-08-01 23/week @ 2024-08-08 20/week @ 2024-08-15 157/week @ 2024-08-22 31/week @ 2024-08-29 10/week @ 2024-09-05 42/week @ 2024-09-12 165/week @ 2024-09-19 476/week @ 2024-09-26 260/week @ 2024-10-03 49/week @ 2024-10-10 96/week @ 2024-10-17 415/week @ 2024-10-24 5582/week @ 2024-10-31 6786/week @ 2024-11-07 6680/week @ 2024-11-14

19,499 downloads per month
Used in 19 crates (5 directly)

MIT license

51KB
1.5K SLoC

iFloat

This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations.

Features

  • Fixed-point arithmetic using FixNumber for deterministic calculations

  • 2D fixed-point vector operations with FixVec

  • Trigonometric functions using fixed-point angles

  • Angle conversion and manipulation utilities in FixAngle

Installation

use i_float::fix_float::FixFloat;
use i_float::fix_vec::FixVec;

How It Works

The `FixFloat` struct uses fixed-point arithmetic to perform calculations with a high degree of precision and determinism. It supports numbers in the range 2^21 - 1 to -2^21 + 1 with a precision of 1/1024, and is most suitable for the range 1,000,000 to -1,000,000 with a precision of 0.01.

Fixed-point numbers are represented using a fixed number of bits for the fractional part. In this implementation, the number of bits representing the fractional part of the fixed-point number is 10, which allows for a precision of 1/1024 or approximately 0.001.

Here are some examples of fixed-point number representation:

  • 1 / 1024 ≈ 0.001 (represented as 1)
  • 256 / 1024 = 0.25 (represented as 256)
  • 1024 / 1024 = 1 (represented as 1024)
  • (1024 + 512) / 1024 = 1.5 (represented as 1536)
  • (2048 + 256) / 1024 = 2.25 (represented as 2304)

By using the `FixFloat` struct, you can perform arithmetic operations using i64 values while maintaining the precision of floating-point numbers, ensuring deterministic behavior across different platforms and devices.

Usage

FixFloat

The `FixFloat` struct represents a fixed-point number using a `i64` as the underlying storage, allowing deterministic arithmetic operations. Use `FixFloat` for calculations instead of `i32` or `i64` when deterministic behavior is required. `FixFloat` provides a way to perform arithmetic operations with `i64` values while maintaining the precision of floating-point numbers.

let a = FixFloat::new_number(1);
let b = FixFloat::new_number(2);
let c = a + b;

FixVec

The `FixVec` struct represents a 2D fixed-point vector, providing various utility methods and operators for vector operations. Use `FixVec` for 2D geometric calculations when deterministic behavior is required.

let a = FixVec::new_number(1, 1);
let b = FixVec::new_number(1, -1);
let c = a + b;

FixAngle

The `FixAngle` class provides various utility methods for working with fixed-point angles, including trigonometric functions and angle conversion.

let fix_angle = FixAngle::new_from_radians_f64(angle);
let fix_sin = fix_angle.sin();
let i64_sin = fix_sin.double();

License

Dependencies

~0.3–1.8MB
~51K SLoC