# Module Js.Float

`module Float: `Js_float``

`val _NaN : `float``
The special value "Not a Number"
• `val isNaN : `float -> bool``
Tests if the given value is `_NaN` Note that both `_NaN = _NaN` and `_NaN == _NaN` will return `false`. `isNaN` is therefore necessary to test for `_NaN`. Returns `true` if the given value is `_NaN`, `false` otherwise
• `val isFinite : `float -> bool``
Tests if the given value is finite Returns `true` if the given value is a finite number, `false` otherwise
• ``` ```(* returns [false] *)
let _ = Js.Float.isFinite infinity

(* returns [false] *)
let _ = Js.Float.isFinite neg_infinity

(* returns [false] *)
let _ = Js.Float.isFinite _NaN

(* returns [true] *)
let _ = Js.Float.isFinite 1234
```  ```
`val toExponential : `float -> string``
Formats a `float` using exponential (scientific) notation Returns a `string` representing the given value in exponential notation
• Raises `RangeError` if digits is not in the range [0, 20] (inclusive)
• ``` ```(* prints "7.71234e+1" *)
let _ = Js.log @@ Js.Float.toExponential 77.1234

(* prints "7.7e+1" *)
let _ = Js.log @@ Js.Float.toExponential 77.
```  ```
`val toExponentialWithPrecision : `float -> digits:int -> string``
Formats a `float` using exponential (scientific) notation digits specifies how many digits should appear after the decimal point. The value must be in the range [0, 20] (inclusive). Returns a `string` representing the given value in exponential notation The output will be rounded or padded with zeroes if necessary.
• Raises `RangeError` if digits is not in the range [0, 20] (inclusive)
• ``` ```(* prints "7.71e+1" *)
let _ = Js.log @@ Js.Float.toExponentialWithPrecision 77.1234 ~digits:2
```  ```
`val toFixed : `float -> string``
Formats a `float` using fixed point notation Returns a `string` representing the given value in fixed-point notation (usually)
• Raises `RangeError` if digits is not in the range [0, 20] (inclusive)
• ``` ```(* prints "12346" (note the rounding) *)
let _ = Js.log @@ Js.Float.toFixed 12345.6789

(* print "1.2e+21" *)
let _ = Js.log @@ Js.Float.toFixed 1.2e21
```  ```
`val toFixedWithPrecision : `float -> digits:int -> string``
Formats a `float` using fixed point notation digits specifies how many digits should appear after the decimal point. The value must be in the range [0, 20] (inclusive). Defaults to `0`. Returns a `string` representing the given value in fixed-point notation (usually) The output will be rounded or padded with zeroes if necessary.
• Raises `RangeError` if digits is not in the range [0, 20] (inclusive)
• ``` ```(* prints "12345.7" (note the rounding) *)
let _ = Js.log @@ Js.Float.toFixedWithPrecision 12345.6789 ~digits:1

(* prints "0.00" (note the added zeroes) *)
let _ = Js.log @@ Js.Float.toFixedWithPrecision 0. ~digits:2
```  ```
`val toPrecision : `float -> string``
Formats a `float` using some fairly arbitrary rules Returns a `string` representing the given value in fixed-point (usually) `toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
• Raises `RangeError` if digits is not in the range accepted by this function (what do you mean "vague"?)
• ``` ```(* prints "12345.6789" *)
let _ = Js.log @@ Js.Float.toPrecision 12345.6789

(* print "1.2e+21" *)
let _ = Js.log @@ Js.Float.toPrecision 1.2e21
```  ```
`val toPrecisionWithPrecision : `float -> digits:int -> string``
Formats a `float` using some fairly arbitrary rules digits specifies how many digits should appear in total. The value must between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows). Returns a `string` representing the given value in fixed-point or scientific notation The output will be rounded or padded with zeroes if necessary. `toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point. `toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number for digits before the decimal point.
• Raises `RangeError` if digits is not in the range accepted by this function (what do you mean "vague"?)
• ``` ```(* prints "1e+4" *)
let _ = Js.log @@ Js.Float.toPrecisionWithPrecision 12345.6789 ~digits:1

(* prints "0.0" *)
let _ = Js.log @@ Js.Float.toPrecisionWithPrecision 0. ~digits:2
```  ```
`val toString : `float -> string``
Formats a `float` as a string Returns a `string` representing the given value in fixed-point (usually)
• ``` ```(* prints "12345.6789" *)
let _ = Js.log @@ Js.Float.toString 12345.6789
```  ```
`val toStringWithRadix : `float -> radix:int -> string``
Formats a `float` as a string radix specifies the radix base to use for the formatted number. The value must be in the range [2, 36] (inclusive). Returns a `string` representing the given value in fixed-point (usually)
• Raises `RangeError` if radix is not in the range [2, 36] (inclusive)
• ``` ```(* prints "110" *)

(* prints "11.001000111101011100001010001111010111000010100011111" *)

```  ```
`val fromString : `string -> float``
Parses the given `string` into a `float` using JavaScript semantics Returns the number as a `float` if successfully parsed, `_NaN` otherwise.
``` ```(* returns 123 *)
let _ = Js.Float.fromString "123"

(* returns 12.3 *)
let _ = Js.Float.fromString "12.3"

(* returns 0 *)
let _ = Js.Float.fromString ""

(* returns 17 *)
let _ = Js.Float.fromString "0x11"

(* returns 3 *)
let _ = Js.Float.fromString "0b11"

(* returns 9 *)
let _ = Js.Float.fromString "0o11"

(* returns [_NaN] *)
let _ = Js.Float.fromString "foo"

(* returns [_NaN] *)
let _ = Js.Float.fromString "100a"
```  ```