Module Stdlib_stable.Float32_uSource
Unboxed 32-bit floating-point arithmetic. This file primarily duplicates functionality from the Float32 module, but for float32#.
OCaml's 32-bit floating-point numbers follow the IEEE 754 standard, using single precision (32 bits) numbers. Floating-point operations never raise an exception on overflow, underflow, division by zero, etc. Instead, special IEEE numbers are returned as appropriate, such as infinity for #1.0s /. #0.0s, neg_infinity for #-1.0s /. #0.0s, and nan ('not a number') for #0.0s /. #0.0s. These special numbers then propagate through floating-point computations as expected: for instance, #1.0s /. infinity is #0.0s, basic arithmetic operations (+., -., *., /.) with nan as an argument return nan, ...
An alias for the type of unboxed 32-bit floating-point numbers.
fma x y z returns x * y + z, with a best effort for computing this expression with a single rounding, using either hardware instructions (providing full IEEE compliance) or a software emulation.
rem a b returns the remainder of a with respect to b. The returned value is a -. n *. b, where n is the quotient a /. b rounded towards zero to an integer.
succ x returns the floating point number right after x i.e., the smallest floating-point number greater than x. See also next_after.
pred x returns the floating-point number right before x i.e., the greatest floating-point number smaller than x. See also next_after.
is_finite x is true if and only if x is finite i.e., not infinite and not nan.
is_infinite x is true if and only if x is infinity or neg_infinity.
is_nan x is true if and only if x is not a number (see nan).
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan or falls outside the range of representable integers.
Convert the given 64-bit integer to the nearest representable 32-bit float.
Convert the given 32-bit float to a 64-bit integer, discarding the fractional part (truncate towards 0). If the truncated floating-point number is outside the range [Int64.min_int, Int64.max_int], no exception is raised, and an unspecified, platform-dependent integer is returned.
Convert a 32-bit integer to a 32-bit float, preserving the value's bit pattern. The amd64 OxCaml compiler translates this call to MOVD.
Convert a 32-bit float to a 32-bit integer, preserving the value's bit pattern. The amd64 OxCaml compiler translates this call to MOVD.
Convert the given string to a float. The string is read in decimal (by default) or in hexadecimal (marked by 0x or 0X). The format of decimal floating-point numbers is [-] dd.ddd (e|E) [+|-] dd , where d stands for a decimal digit. The format of hexadecimal floating-point numbers is [-] 0(x|X) hh.hhh (p|P) [+|-] dd , where h stands for an hexadecimal digit and d for a decimal digit. In both cases, at least one of the integer and fractional parts must be given; the exponent part is optional. The _ (underscore) character can appear anywhere in the string and is ignored. Depending on the execution platforms, other representations of floating-point numbers can be accepted, but should not be relied upon.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf.
This function is an alias for Stdlib.string_of_float.
The five classes of floating-point numbers, as determined by the classify_float function.
Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
expm1 x computes exp x -. #1.0s, giving numerically-accurate results even if x is close to #0.0s.
log1p x computes log(#1.0s +. x) (natural logarithm), giving numerically-accurate results even if x is close to #0.0s.
Arc cosine. The argument must fall within the range [-1.0s, 1.0s]. Result is in radians and is between 0.0s and pi.
Arc sine. The argument must fall within the range [-1.0s, 1.0s]. 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. If one of x or y is infinite, returns infinity even if the other is nan.
Hyperbolic arc cosine. The argument must fall within the range [1.0s, inf]. Result is in radians and is between 0.0s 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.0s, 1.0s]. Result is in radians and ranges over the entire real line.
Error function. The argument ranges over the entire real line. The result is always within [-1.0s, 1.0s].
Complementary error function (erfc x = 1 - erf x). The argument ranges over the entire real line. The result is always within [-1.0s, 1.0s].
trunc x rounds x to the nearest integer whose absolute value is less than or equal to x.
round x rounds x to the nearest integer with ties (fractional values of 0.5) rounded away from zero, regardless of the current rounding direction. If x is an integer, #+0.s, #-0.s, nan, or infinite, x itself is returned.
On 64-bit mingw-w64, this function may be emulated owing to a bug in the C runtime library (CRT) on this platform.
Round above to an integer value. ceil f returns the least integer value greater than or equal to f. The result is returned as a float.
Round below to an integer value. floor f returns the greatest integer value less than or equal to f. The result is returned as a float.
next_after x y returns the next representable floating-point value following x in the direction of y. More precisely, if y is greater (resp. less) than x, it returns the smallest (resp. largest) representable number greater (resp. less) than x. If x equals y, the function returns y. If x or y is nan, a nan is returned. Note that next_after max_float infinity = infinity and that next_after #0. infinity is the smallest denormalized positive number. If x is the smallest denormalized positive number, next_after x #0. = #0.
copy_sign 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.
sign_bit x is true if and only if the sign bit of x is set. For example sign_bit #1. and signbit #0. are false while sign_bit #-1. and sign_bit #-0. are true.
compare x y returns 0 if x is equal to y, a negative integer if x is less than y, and a positive integer if x is greater than y. compare treats nan as equal to itself and less than any other float value. This treatment of nan ensures that compare defines a total ordering relation.
The equal function for floating-point numbers, compared using compare.
min x y returns the minimum of x and y. It returns nan when x or y is nan. Moreover min #-0.s #+0.s = #-0.s
max x y returns the maximum of x and y. It returns nan when x or y is nan. Moreover max #-0.s #+0.s = #+0.s
min_num x y returns the minimum of x and y treating nan as missing values. If both x and y are nan, nan is returned. Moreover min_num #-0.s #+0.s = #-0.s
max_num x y returns the maximum of x and y treating nan as missing values. If both x and y are nan nan is returned. Moreover max_num #-0.s #+0.s = #+0.s
Rounds a float32# to an int64# using the current rounding mode. The default rounding mode on amd64 is "round half to even", and we expect that no program will change the mode. The default mode may differ on other platforms. If the argument is NaN or infinite or if the rounded value cannot be represented, then the result is unspecified. The amd64 OxCaml compiler translates this call to CVTSS2SI.
Rounds a float32# to an integer float32# using the current rounding mode. The default rounding mode on amd64 is "round half to even", and we expect that no program will change the mode. The default mode may differ on other platforms. The amd64 OxCaml compiler translates this call to ROUNDSS.
Rounds a float32# down to the next integer float32# toward negative infinity. The amd64 OxCaml compiler translates this call to ROUNDSS.
Rounds a float32# up to the next integer float32# toward positive infinity. The amd64 OxCaml compiler translates this call to ROUNDSS.
Rounds a float32# to the next integer float32# toward zero. The amd64 OxCaml compiler translates this call to ROUNDSS.