Up  

Module type Float_intf.S


module type S = sig .. end
type t 
type outer = t 
include Sexpable.S
include Binable.S
include Floatable.S
include Stringable.S
include Hashable.S_binable
include Comparable.S_binable
include Robustly_comparable.S
val max_value : t
val min_value : t
val zero : t
val epsilon : t
val max_finite_value : t
val min_finite_value : t
val of_int : int -> t
val to_int : t -> int
val of_int64 : int64 -> t
val to_int64 : t -> int64
val round_towards_zero_exn : t -> int
round_towards_zero_exn raises Invalid_argument when either trying to handle nan or trying to handle a float outside the range (-. 2. ** 52., 2. ** 52.) (since floats have 52 significant bits) or outside the range (float min_int, float max_int)
val round_towards_zero : t -> int option
round_towards_zero returns None if round_towards_zero_exn raises an exception
val round : t -> t
val round_down_exn : t -> int
val round_down : t -> int option
val round_up_exn : t -> int
val round_up : t -> int option
val iround_exn : t -> int
iround_exn raises Invalid_argument in the same cases as round_towards_zero_exn

iround returns None if iround_exn raises an exception

val iround : t -> int option
iround t rounds t to the nearest int. Returns None when t is too large to round to an int.
val is_nan : t -> bool
Ordinary float-only nan test.
val is_inf : t -> bool
Ordinary float-only infinity test.
val min_inan : t -> t -> t
min that returns the other value if one of the values is a nan.
val max_inan : t -> t -> t
max that returns the other value if one of the values is a nan.
val (+) : t -> t -> t
val (-) : t -> t -> t
val ( * ) : t -> t -> t
val (/) : t -> t -> t
module Parts: sig .. end
Returns the fractional part and the whole (i.e. 
val modf : t -> Parts.t
val floor : t -> t
val ceil : t -> t
val mod_float : t -> t -> t
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 %.
val add : t -> t -> t
val sub : t -> t -> t
val neg : t -> t
val scale : t -> t -> t
val abs : t -> t
module Class: sig .. end
val classify : t -> Class.t
module Sign: sig .. end
val sign : t -> Sign.t
module Terse: sig .. end