Module Stdlib.Float

Contents

Instructions: Use this module in your project

In the IDE (CLion, Visual Studio Code, Xcode, etc.) you use for your DkSDK project:

  1. Add the following to your project's dependencies/CMakeLists.txt:

    Copy
    DkSDKProject_DeclareAvailable(ocaml
    CONSTRAINT "= 4.14.0"
    FINDLIBS str unix runtime_events threads dynlink)
DkSDKProject_MakeAvailable(ocaml)

  2. Add the Findlib::ocaml library to any desired targets in src/*/CMakeLists.txt:

    Copy
    target_link_libraries(YourPackage_YourLibraryName
     # ... existing libraries, if any ...
     Findlib::ocaml)

  3. Click your IDE's Build button

Not using DkSDK?

FIRST, do one or all of the following:

  1. Run:

    Copy
    opam install ocaml.4.14.0

  2. Edit your dune-project and add:

    Copy
    (package
  (name YourExistingPackage)
  (depends
  ; ... existing dependenices ...
  (ocaml (>= 4.14.0))))

    Then run:

    Copy
    dune build *.opam # if this fails, run: dune build

  3. Edit your <package>.opam file and add:

    Copy
    depends: [
  # ... existing dependencies ...
  "ocaml" {>= "4.14.0"}
]

    Then run:

    Copy
    opam install . --deps-only

FINALLY, add the library to any desired (library)and/or (executable) targets in your **/dune files:

Copy
(library
  (name YourLibrary)
  ; ... existing library options ...
  (libraries
    ; ... existing libraries ...
    ))

(executable
  (name YourExecutable)
  ; ... existing executable options ...
  (libraries
    ; ... existing libraries ...
    ))
val zero : float

The floating point 0.

  • since 4.08.0
val one : float

The floating-point 1.

  • since 4.08.0
val minus_one : float

The floating-point -1.

  • since 4.08.0
valneg : ``float-> float

Unary negation.

valadd : ``float->``float-> float

Floating-point addition.

valsub : ``float->``float-> float

Floating-point subtraction.

valmul : ``float->``float-> float

Floating-point multiplication.

valdiv : ``float->``float-> float

Floating-point division.

valfma : ``float->``float->``float-> float

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.

On 64-bit Cygwin, 64-bit mingw-w64 and MSVC 2017 and earlier, this function may be emulated owing to known bugs on limitations on these platforms. Note: since software emulation of the fma is costly, make sure that you are using hardware fma support if performance matters.

  • since 4.08.0
valrem : ``float->``float-> float

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.

valsucc : ``float-> float

succ x returns the floating point number right after x i.e., the smallest floating-point number greater than x. See also next_after.

  • since 4.08.0
valpred : ``float-> float

pred x returns the floating-point number right before x i.e., the greatest floating-point number smaller than x. See also next_after.

  • since 4.08.0
valabs : ``float-> float

abs f returns the absolute value of f.

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 pi : float

The constant pi.

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

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

valis_finite : ``float-> bool

is_finite x is true if and only if x is finite i.e., not infinite and not nan.

  • since 4.08.0
valis_infinite : ``float-> bool

is_infinite x is true if and only if x is infinity or neg_infinity.

  • since 4.08.0
valis_nan : ``float-> bool

is_nan x is true if and only if x is not a number (see nan).

  • since 4.08.0
valis_integer : ``float-> bool

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

  • since 4.08.0
valof_int : ``int-> float

Convert an integer to floating-point.

valto_int : ``float-> int

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.

valof_string : ``string-> float

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.

  • raises Failure

    if the given string is not a valid representation of a float.

valof_string_opt : ``string-> ``float option

Same as of_string, but returns None instead of raising.

valto_string : ``float-> string

Return the string representation of a floating-point number.

typefpclass`` =fpclass=

    

  1. 

| FP_normal


(*
Normal number, none of the below


*)

   
    

  1. 

| FP_subnormal


(*
Number very close to 0.0, has reduced precision


*)

   
    

  1. 

| FP_zero


(*
Number is 0.0 or -0.0


*)

   
    

  1. 

| FP_infinite


(*
Number is positive or negative infinity


*)

   
    

  1. 

| FP_nan


(*
Not a number: result of an undefined operation


*)

The five classes of floating-point numbers, as determined by the classify_float function.

valclassify_float : ``float-> fpclass

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

valpow : ``float->``float-> float

Exponentiation.

valsqrt : ``float-> float

Square root.

valcbrt : ``float-> float

Cube root.

  • since 4.13.0
valexp : ``float-> float

Exponential.

valexp2 : ``float-> float

Base 2 exponential function.

  • since 4.13.0
vallog : ``float-> float

Natural logarithm.

vallog10 : ``float-> float

Base 10 logarithm.

vallog2 : ``float-> float

Base 2 logarithm.

  • since 4.13.0
valexpm1 : ``float-> float

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

vallog1p : ``float-> float

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

valcos : ``float-> float

Cosine. Argument is in radians.

valsin : ``float-> float

Sine. Argument is in radians.

valtan : ``float-> float

Tangent. Argument is in radians.

valacos : ``float-> float

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

valasin : ``float-> float

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.

valatan : ``float-> float

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

valatan2 : ``float->``float-> float

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.

valhypot : ``float->``float-> float

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.

valcosh : ``float-> float

Hyperbolic cosine. Argument is in radians.

valsinh : ``float-> float

Hyperbolic sine. Argument is in radians.

valtanh : ``float-> float

Hyperbolic tangent. Argument is in radians.

valacosh : ``float-> float

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

  • since 4.13.0
valasinh : ``float-> float

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

  • since 4.13.0
valatanh : ``float-> float

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.

  • since 4.13.0
valerf : ``float-> float

Error function. The argument ranges over the entire real line. The result is always within [-1.0, 1.0].

  • since 4.13.0
valerfc : ``float-> float

Complementary error function (erfc x = 1 - erf x). The argument ranges over the entire real line. The result is always within [-1.0, 1.0].

  • since 4.13.0
valtrunc : ``float-> float

trunc x rounds x to the nearest integer whose absolute value is less than or equal to x.

  • since 4.08.0
valround : ``float-> float

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., -0., 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.

  • since 4.08.0
valceil : ``float-> float

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.

valfloor : ``float-> 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.

valnext_after : ``float->``float-> 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.

  • since 4.08.0
valcopy_sign : ``float->``float-> float

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.

valsign_bit : ``float-> bool

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.

  • since 4.08.0
valfrexp : ``float-> float * int

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.

valldexp : ``float->``int-> float

ldexp x n returns x *. 2 ** n.

valmodf : ``float-> float * float

modf f returns the pair of the fractional and integral part of f.

type t`` = float

An alias for the type of floating-point numbers.

valcompare :t -> t -> int

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.

valequal :t -> t -> bool

The equal function for floating-point numbers, compared using compare.

valmin :t -> t -> t

min x y returns the minimum of x and y. It returns nan when x or y is nan. Moreover min (-0.) (+0.) = -0.

  • since 4.08.0
valmax : ``float->``float-> float

max x y returns the maximum of x and y. It returns nan when x or y is nan. Moreover max (-0.) (+0.) = +0.

  • since 4.08.0
valmin_max : ``float->``float-> float * float

min_max x y is (min x y, max x y), just more efficient.

  • since 4.08.0
valmin_num :t -> t -> t

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.) (+0.) = -0.

  • since 4.08.0
valmax_num :t -> t -> t

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.) (+0.) = +0.

  • since 4.08.0
valmin_max_num : ``float->``float-> float * float

min_max_num x y is (min_num x y, max_num x y), just more efficient. Note that in particular min_max_num x nan = (x, x) and min_max_num nan y = (y, y).

  • since 4.08.0
valhash :t -> int

The hash function for floating-point numbers.

module Array:sig...end

Float arrays with packed representation.

module ArrayLabels:sig...end

Float arrays with packed representation (labeled functions).

More from the DkSDK Book

    1. DkSDK
      1. Package capnp
        1. Module Capnp
        1. Module Capnp_unix
      1. Package cmdliner
        1. Module Cmdliner
        1. Module Cmdliner_arg
        1. Module Cmdliner_base
        1. Module Cmdliner_cline
        1. Module Cmdliner_cmd
        1. Module Cmdliner_docgen
        1. Module Cmdliner_eval
        1. Module Cmdliner_info
        1. Module Cmdliner_manpage
        1. Module Cmdliner_msg
        1. Module Cmdliner_term
        1. Module Cmdliner_term_deprecated
        1. Module Cmdliner_trie
      1. Package fmt
        1. Module Fmt
        1. Module Fmt_cli
        1. Module Fmt_tty
      1. Package logs
        1. Module Logs
        1. Module Logs_cli
        1. Module Logs_fmt
        1. Module Logs_lwt
        1. Module Logs_threaded
      1. Package lwt
        1. Module Lwt
        1. Module Lwt_bytes
        1. Module Lwt_condition
        1. Module Lwt_config
        1. Module Lwt_engine
        1. Module Lwt_features
        1. Module Lwt_fmt
        1. Module Lwt_gc
        1. Module Lwt_io
        1. Module Lwt_list
        1. Module Lwt_main
        1. Module Lwt_mutex
        1. Module Lwt_mvar
        1. Module Lwt_pool
        1. Module Lwt_pqueue
        1. Module Lwt_preemptive
        1. Module Lwt_process
        1. Module Lwt_result
        1. Module Lwt_seq
        1. Module Lwt_sequence
        1. Module Lwt_stream
        1. Module Lwt_switch
        1. Module Lwt_sys
        1. Module Lwt_throttle
        1. Module Lwt_timeout
        1. Module Lwt_unix
      1. Package mtime
        1. Module Mtime
        1. Module Mtime_clock
      1. Package ocaml
        1. Module Bigarray
        1. Module Condition
        1. Module Dynlink
        1. Module Event
        1. Module Mutex
        1. Module Profiling
        1. Module Semaphore
        1. Module Stdlib
          1. ...
          1. Module Stdlib.Float
            1. Module Float.Array
            1. Module Float.ArrayLabels
        1. Module Str
        1. Module Thread
        1. Module ThreadUnix
        1. Module Topdirs
        1. Module Unix
        1. Module UnixLabels
      1. Package
      1. Package result
        1. Module Result
      1. Package stdint
        1. Module Stdint
Logo for Diskuv

The development kit to create safe software and products.