Module Float_u

Utilities for unboxed floats. This module is mostly a copy of Base's Float module, but with much functionality missing because it can't yet be implemented for unboxed floats or unboxed types generally.

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

between t ~low ~high means low <= t <= high

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

Equal to infinity.

Equal to neg_infinity.

The constant pi.

The constant sqrt(pi).

The constant sqrt(2 * pi).

Euler-Mascheroni constant (γ).

The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0. That is:

epsilon_float = (one_ulp `Up 1.0) -. 1.0

This gives the relative accuracy of type t, in the sense that for numbers on the order of x, the roundoff error is on the order of x *. float_epsilon.

See also: Machine epsilon.

An order-preserving bijection between all floats except for nans, and all int64s with absolute value smaller than or equal to 2**63 - 2**52. Note both 0. and -0. map to 0L.

Returns nan if the absolute value of the argument is too large.

The next or previous representable float. ULP stands for "unit of least precision", and is the spacing between floating point numbers. Both one_ulp `Up infinity and one_ulp `Down neg_infinity return a nan.

round rounds a float to an integer float. iround{,_exn} rounds a float to an int. Both round according to a direction dir, with default dir being `Nearest.

  | `Down    | rounds toward Float.neg_infinity                             |
  | `Up      | rounds toward Float.infinity                                 |
  | `Nearest | rounds to the nearest int ("round half-integers up")         |
  | `Zero    | rounds toward zero                                           |

iround_exn raises when trying to handle nan or trying to handle a float outside the range [float min_int, float max_int).

Here are some examples for round for each direction:

  | `Down    | [-2.,-1.)   to -2. | [-1.,0.)   to -1. | [0.,1.) to 0., [1.,2.) to 1. |
  | `Up      | (-2.,-1.]   to -1. | (-1.,0.]   to -0. | (0.,1.] to 1., (1.,2.] to 2. |
  | `Zero    | (-2.,-1.]   to -1. | (-1.,1.)   to 0.  | [1.,2.) to 1.                |
  | `Nearest | [-1.5,-0.5) to -1. | [-0.5,0.5) to 0.  | [0.5,1.5) to 1.              |

For convenience, versions of these functions with the dir argument hard-coded are provided. If you are writing performance-critical code you should use the versions with the hard-coded arguments (e.g. iround_down_exn). The _exn ones are the fastest.

The following properties hold:

• of_int (iround_*_exn i) = i for any float i that is an integer with min_int <= i <= max_int.

• round_* i = i for any float i that is an integer.

• iround_*_exn (of_int i) = i for any int i with -2**52 <= i <= 2**52.

Rounds half integers up.

Rounds half integers to the even integer.

round_significant x ~significant_digits:n rounds to the nearest number with n significant digits. More precisely: it returns the representable float closest to x rounded to n significant digits. It is meant to be equivalent to sprintf "%.*g" n x |> Float.of_string but faster (10x-15x). Exact ties are resolved as round-to-even.

However, it might in rare cases break the contract above.

It might in some cases appear as if it violates the round-to-even rule:

  let x = 4.36083208835
  let z = 4.3608320883;;

  assert (z = fast_approx_round_significant x ~sf:11)

But in this case so does sprintf, since x as a float is slightly under-represented:

  sprintf "%.11g" x = "4.3608320883";;
  sprintf "%.30g" x = "4.36083208834999958014577714493"

More importantly, round_significant might sometimes give a different result than sprintf ... |> Float.of_string because it round-trips through an integer. For example, the decimal fraction 0.009375 is slightly under-represented as a float:

  sprintf "%.17g" 0.009375 = "0.0093749999999999997"

But:

  0.009375 *. 1e5 = 937.5

Therefore:

  round_significant 0.009375 ~significant_digits:3 = 0.00938

whereas:

  sprintf "%.3g" 0.009375 = "0.00937"

In general we believe (and have tested on numerous examples) that the following holds for all x:

  let s = sprintf "%.*g" significant_digits x |> Float.of_string in
  s = round_significant ~significant_digits x
  || s = round_significant ~significant_digits (one_ulp `Up x)
  || s = round_significant ~significant_digits (one_ulp `Down x)

Also, for float representations of decimal fractions (like 0.009375), round_significant is more likely to give the "desired" result than sprintf ... |> of_string (that is, the result of rounding the decimal fraction, rather than its float representation). But it's not guaranteed either--see the 4.36083208835 example above.

round_decimal x ~decimal_digits:n rounds x to the nearest 10**(-n). For positive n it is meant to be equivalent to sprintf "%.*f" n x |> Float.of_string, but faster.

All the considerations mentioned in round_significant apply (both functions use the same code path).

A float is infinite when it is either infinity or neg_infinity.

A float is finite when neither is_nan nor is_inf is true.

is_integer x is true if and only if x is an integer.

mod_float x y returns a result with the same sign as x. It returns nan if y is 0. It is basically

  let mod_float x y = x -. (float (truncate (x /. y)) *. y)

not

  let mod_float x y = x -. (floor (x /. y) *. y)

and therefore resembles mod on integers more than %.

Ordinary functions for arithmetic operations

These are for modules that inherit from t, since the infix operators are more convenient.

A sub-module designed to be opened to make working with floats more convenient.

In analogy to Int.( % ), ( % ):

• always produces non-negative (or NaN) result
• raises when given a negative modulus.

Like the other infix operators, NaNs in mean NaNs out.

Other cases: (a % Infinity) = a when 0 <= a < Infinity, (a % Infinity) = Infinity when -Infinity < a < 0, (+/- Infinity % a) = NaN, (a % 0) = NaN.

Note that this doesn't round trip in either direction. For example, Float.to_int (Float.of_int max_int) <> max_int.

Similar to O, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

to_string x builds a string s representing the float x that guarantees the round trip, that is such that Float_u.equal x (Float_u.of_string s).

It usually yields as few significant digits as possible. That is, it won't print 3.14 as 3.1400000000000001243. The only exception is that occasionally it will output 17 significant digits when the number can be represented with just 16 (but not 15 or less) of them.

of_string is inverse to to_string.

Pretty print float, for example to_string_hum ~decimals:3 1234.1999 = "1_234.200" to_string_hum ~decimals:3 ~strip_zero:true 1234.1999 = "1_234.2" . No delimiters are inserted to the right of the decimal.

Produce a lossy compact string representation of the float. The float is scaled by an appropriate power of 1000 and rendered with one digit after the decimal point, except that the decimal point is written as '.', 'k', 'm', 'g', 't', or 'p' to indicate the scale factor. (However, if the digit after the "decimal" point is 0, it is suppressed.)

The smallest scale factor that allows the number to be rendered with at most 3 digits to the left of the decimal is used. If the number is too large for this format (i.e., the absolute value is at least 999.95e15), scientific notation is used instead. E.g.:

• to_padded_compact_string (-0.01) = "-0 "
• to_padded_compact_string 1.89 = "1.9"
• to_padded_compact_string 999_949.99 = "999k9"
• to_padded_compact_string 999_950. = "1m "

In the case where the digit after the "decimal", or the "decimal" itself is omitted, the numbers are padded on the right with spaces to ensure the last two columns of the string always correspond to the decimal and the digit afterward (except in the case of scientific notation, where the exponent is the right-most element in the string and could take up to four characters).

• to_padded_compact_string 1. = "1 "
• to_padded_compact_string 1.e6 = "1m "
• to_padded_compact_string 1.e16 = "1.e+16"
• to_padded_compact_string max_finite_value = "1.8e+308"

Numbers in the range -.05 < x < .05 are rendered as "0 " or "-0 ".

Other cases:

• to_padded_compact_string nan = "nan "
• to_padded_compact_string infinity = "inf "
• to_padded_compact_string neg_infinity = "-inf "

Exact ties are resolved to even in the decimal:

• to_padded_compact_string 3.25 = "3.2"
• to_padded_compact_string 3.75 = "3.8"
• to_padded_compact_string 33_250. = "33k2"
• to_padded_compact_string 33_350. = "33k4"

to_padded_compact_string is defined in terms of to_padded_compact_string_custom below as

  let to_padded_compact_string t =
    to_padded_compact_string_custom
      t
      ?prefix:None
      ~kilo:"k"
      ~mega:"m"
      ~giga:"g"
      ~tera:"t"
      ~peta:"p"
      ()
  ;;

Similar to to_padded_compact_string but allows the user to provide different abbreviations. This can be useful to display currency values, e.g. $1mm3, where prefix="$", mega="mm".

int_pow x n computes x ** float n via repeated squaring. It is generally much faster than **.

Note that int_pow x 0 always returns 1., even if x = nan. This coincides with x ** 0. and is intentional.

For n >= 0 the result is identical to an n-fold product of x with itself under *., with a certain placement of parentheses. For n < 0 the result is identical to int_pow (1. /. x) (-n).

The error will be on the order of |n| ulps, essentially the same as if you perturbed x by up to a ulp and then exponentiated exactly.

Benchmarks show a factor of 5-10 speedup (relative to **) for exponents up to about 1000 (approximately 10ns vs. 70ns). For larger exponents the advantage is smaller but persists into the trillions. For a recent or more detailed comparison, run the benchmarks.

Depending on context, calling this function might or might not allocate 2 minor words. Even if called in a way that causes allocation, it still appears to be faster than **.

square x returns x *. x.

ldexp x n returns x *. 2 ** n

Base 10 logarithm.

Base 2 logarithm.

expm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.

log1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.

copysign x y returns a float whose absolute value is that of x and whose sign is that of y. If x is nan, returns nan. If y is nan, returns either x or -. x, but it is not specified which.

Cosine. Argument is in radians.

Sine. Argument is in radians.

Tangent. Argument is in radians.

Arc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.

Arc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.

Arc tangent. Result is in radians and is between -pi/2 and pi/2.

atan2 y x returns the arc tangent of y /. x. The signs of x and y are used to determine the quadrant of the result. Result is in radians and is between -pi and pi.

hypot x y returns sqrt(x *. x + y *. y), that is, the length of the hypotenuse of a right-angled triangle with sides of length x and y, or, equivalently, the distance of the point (x,y) to origin.

Hyperbolic cosine. Argument is in radians.

Hyperbolic sine. Argument is in radians.

Hyperbolic tangent. Argument is in radians.

Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]. Result is in radians and is between 0.0 and inf.

Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.

Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]. Result is in radians and ranges over the entire real line.

Square root.

Exponential.

Natural logarithm.

Excluding nan the floating-point "number line" looks like:

• deprecated [since 2016-01] Replace [sign] with [robust_sign] or [sign_exn]

The sign of a float. Both -0. and 0. map to Zero. Raises on nan. All other values map to Neg or Pos.

The sign of a float, with support for NaN. Both -0. and 0. map to Zero. All NaN values map to Nan. All other values map to Neg or Pos.

Branchless, as Bool.select.

Branchless.

The Array module provides some helpers that wrap common operations on floatarrays with appropriate boxing or unboxing to work with float#.

The Polymorphic_array_helpers module provides some helpers that wrap common operations on float arrays with appropriate boxing or unboxing to work with float#.