Protocol environment / Pervasives: remove floating-point arithmetic
Also remove string conversion functions for float.
This commit is contained in:
bruno
Benjamin Canou
parent
3ae114f1c9
commit
5e73ef8fea
@ -18,7 +18,8 @@
|
||||
* Import version 4.06.1
|
||||
* Remove [channel], [exit], ...
|
||||
* Remove polymorphic comparisons
|
||||
* Remove non IEEE754-standardized functions on floats
|
||||
* Remove floating-point arithmetic
|
||||
* Remove string conversion functions for float
|
||||
* Remove deprecated functions
|
||||
|
||||
*)
|
||||
@ -257,148 +258,6 @@ external ( asr ) : int -> int -> int = "%asrint"
|
||||
Right-associative operator at precedence level 8/11. *)
|
||||
|
||||
|
||||
(** {1 Floating-point arithmetic}
|
||||
|
||||
OCaml's floating-point numbers follow the
|
||||
IEEE 754 standard, using double precision (64 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.0 /. 0.0],
|
||||
[neg_infinity] for [-1.0 /. 0.0], and [nan] ('not a number')
|
||||
for [0.0 /. 0.0]. These special numbers then propagate through
|
||||
floating-point computations as expected: for instance,
|
||||
[1.0 /. infinity] is [0.0], and any arithmetic operation with [nan]
|
||||
as argument returns [nan] as result.
|
||||
*)
|
||||
|
||||
external ( ~-. ) : float -> float = "%negfloat"
|
||||
(** Unary negation. You can also write [-. e] instead of [~-. e].
|
||||
Unary operator at precedence level 9/11 for [-. e]
|
||||
and 11/11 for [~-. e]. *)
|
||||
|
||||
external ( ~+. ) : float -> float = "%identity"
|
||||
(** Unary addition. You can also write [+. e] instead of [~+. e].
|
||||
Unary operator at precedence level 9/11 for [+. e]
|
||||
and 11/11 for [~+. e].
|
||||
@since 3.12.0
|
||||
*)
|
||||
|
||||
external ( +. ) : float -> float -> float = "%addfloat"
|
||||
(** Floating-point addition.
|
||||
Left-associative operator at precedence level 6/11. *)
|
||||
|
||||
external ( -. ) : float -> float -> float = "%subfloat"
|
||||
(** Floating-point subtraction.
|
||||
Left-associative operator at precedence level 6/11. *)
|
||||
|
||||
external ( *. ) : float -> float -> float = "%mulfloat"
|
||||
(** Floating-point multiplication.
|
||||
Left-associative operator at precedence level 7/11. *)
|
||||
|
||||
external ( /. ) : float -> float -> float = "%divfloat"
|
||||
(** Floating-point division.
|
||||
Left-associative operator at precedence level 7/11. *)
|
||||
|
||||
external ceil : float -> float = "caml_ceil_float" "ceil"
|
||||
[@@unboxed] [@@noalloc]
|
||||
(** 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. *)
|
||||
|
||||
external floor : float -> float = "caml_floor_float" "floor"
|
||||
[@@unboxed] [@@noalloc]
|
||||
(** 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. *)
|
||||
|
||||
external abs_float : float -> float = "%absfloat"
|
||||
(** [abs_float f] returns the absolute value of [f]. *)
|
||||
|
||||
external copysign : float -> float -> float
|
||||
= "caml_copysign_float" "caml_copysign"
|
||||
[@@unboxed] [@@noalloc]
|
||||
(** [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.
|
||||
@since 4.00.0 *)
|
||||
|
||||
external mod_float : float -> float -> float = "caml_fmod_float" "fmod"
|
||||
[@@unboxed] [@@noalloc]
|
||||
(** [mod_float 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. *)
|
||||
|
||||
external frexp : float -> float * int = "caml_frexp_float"
|
||||
(** [frexp f] returns the pair of the significant
|
||||
and the exponent of [f]. When [f] is zero, the
|
||||
significant [x] and the exponent [n] of [f] are equal to
|
||||
zero. When [f] is non-zero, they are defined by
|
||||
[f = x *. 2 ** n] and [0.5 <= x < 1.0]. *)
|
||||
|
||||
|
||||
external ldexp : (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed]) =
|
||||
"caml_ldexp_float" "caml_ldexp_float_unboxed" [@@noalloc]
|
||||
(** [ldexp x n] returns [x *. 2 ** n]. *)
|
||||
|
||||
external modf : float -> float * float = "caml_modf_float"
|
||||
(** [modf f] returns the pair of the fractional and integral
|
||||
part of [f]. *)
|
||||
|
||||
external float : int -> float = "%floatofint"
|
||||
(** Same as {!Pervasives.float_of_int}. *)
|
||||
|
||||
external float_of_int : int -> float = "%floatofint"
|
||||
(** Convert an integer to floating-point. *)
|
||||
|
||||
external truncate : float -> int = "%intoffloat"
|
||||
(** Same as {!Pervasives.int_of_float}. *)
|
||||
|
||||
external int_of_float : float -> int = "%intoffloat"
|
||||
(** 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. *)
|
||||
|
||||
val infinity : float
|
||||
(** Positive infinity. *)
|
||||
|
||||
val neg_infinity : float
|
||||
(** Negative infinity. *)
|
||||
|
||||
val nan : float
|
||||
(** A special floating-point value denoting the result of an
|
||||
undefined operation such as [0.0 /. 0.0]. Stands for
|
||||
'not a number'. Any floating-point operation with [nan] as
|
||||
argument returns [nan] as result. As for floating-point comparisons,
|
||||
[=], [<], [<=], [>] and [>=] return [false] and [<>] returns [true]
|
||||
if one or both of their arguments is [nan]. *)
|
||||
|
||||
val max_float : float
|
||||
(** The largest positive finite value of type [float]. *)
|
||||
|
||||
val min_float : float
|
||||
(** The smallest positive, non-zero, non-denormalized value of type [float]. *)
|
||||
|
||||
val epsilon_float : float
|
||||
(** The difference between [1.0] and the smallest exactly representable
|
||||
floating-point number greater than [1.0]. *)
|
||||
|
||||
type fpclass =
|
||||
FP_normal (** Normal number, none of the below *)
|
||||
| FP_subnormal (** Number very close to 0.0, has reduced precision *)
|
||||
| FP_zero (** Number is 0.0 or -0.0 *)
|
||||
| FP_infinite (** Number is positive or negative infinity *)
|
||||
| FP_nan (** Not a number: result of an undefined operation *)
|
||||
(** The five classes of floating-point numbers, as determined by
|
||||
the {!Pervasives.classify_float} function. *)
|
||||
|
||||
external classify_float : (float [@unboxed]) -> fpclass =
|
||||
"caml_classify_float" "caml_classify_float_unboxed" [@@noalloc]
|
||||
(** Return the class of the given floating-point number:
|
||||
normal, subnormal, zero, infinite, or not a number. *)
|
||||
|
||||
|
||||
(** {1 String operations}
|
||||
|
||||
More string operations are provided in module {!String}.
|
||||
@ -480,31 +339,6 @@ val int_of_string_opt: string -> int option
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
val string_of_float : float -> string
|
||||
(** Return the string representation of a floating-point number. *)
|
||||
|
||||
external float_of_string : string -> float = "caml_float_of_string"
|
||||
(** 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.
|
||||
Raise [Failure "float_of_string"] if the given string is not a valid
|
||||
representation of a float. *)
|
||||
|
||||
val float_of_string_opt: string -> float option
|
||||
(** Same as [float_of_string], but returns [None] instead of raising.
|
||||
@since 4.05
|
||||
*)
|
||||
|
||||
(** {1 Pair operations} *)
|
||||
|
||||
external fst : 'a * 'b -> 'a = "%field0"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user