Module Js.Math

Bindings to the functions in the Math object

JavaScript Math API

val _E : float

let _E: float;

Euler's number

val _LN2 : float

let _LN2: float;

natural logarithm of 2

val _LN10 : float

let _LN10: float;

natural logarithm of 10

val _LOG2E : float

let _LOG2E: float;

base 2 logarithm of E

val _LOG10E : float

let _LOG10E: float;

base 10 logarithm of E

val _PI : float

let _PI: float;

Pi... (ratio of the circumference and diameter of a circle)

val _SQRT1_2 : float

let _SQRT1_2: float;

square root of 1/2

val _SQRT2 : float

let _SQRT2: float;

square root of 2

val abs_int : int -> int

let abs_int: int => int;

absolute value

val abs_float : float -> float

let abs_float: float => float;

absolute value

val acos : float -> float

let acos: float => float;

arccosine in radians, can return NaN

val acosh : float -> float

let acosh: float => float;

hyperbolic arccosine in raidans, can return NaN, ES2015

val asin : float -> float

let asin: float => float;

arcsine in radians, can return NaN

val asinh : float -> float

let asinh: float => float;

hyperbolic arcsine in raidans, ES2015

val atan : float -> float

let atan: float => float;

arctangent in radians

val atanh : float -> float

let atanh: float => float;

hyperbolic arctangent in radians, can return NaN, ES2015

val atan2 : y:float -> x:float -> float

let atan2: y:float => x:float => float;

arctangent of the quotient of x and y, mostly... this one's a bit weird

val cbrt : float -> float

let cbrt: float => float;

cube root, can return NaN, ES2015

val unsafe_ceil_int : float -> int

let unsafe_ceil_int: float => int;

may return values not representable by int

val ceil_int : float -> int

let ceil_int: float => int;

smallest int greater than or equal to the argument

val ceil_float : float -> float

let ceil_float: float => float;

smallest float greater than or equal to the argument

val clz32 : int -> int

let clz32: int => int;

number of leading zero bits of the argument's 32 bit int representation, ES2015

val cos : float -> float

let cos: float => float;

cosine in radians

val cosh : float -> float

let cosh: float => float;

hyperbolic cosine in radians, ES2015

val exp : float -> float

let exp: float => float;

natural exponentional

val expm1 : float -> float

let expm1: float => float;

natural exponential minus 1, ES2015

val unsafe_floor_int : float -> int

let unsafe_floor_int: float => int;

may return values not representable by int

val floor_int : float -> int

let floor_int: float => int;

largest int greater than or equal to the arugment

val floor_float : float -> float

let floor_float: float => float;

val fround : float -> float

let fround: float => float;

round to nearest single precision float, ES2015

val hypot : float -> float -> float

let hypot: float => float => float;

pythagorean equation, ES2015

val hypotMany : float array -> float

let hypotMany: array(float) => float;

generalized pythagorean equation, ES2015

val imul : int -> int -> int

let imul: int => int => int;

32-bit integer multiplication, ES2015

val log : float -> float

let log: float => float;

natural logarithm, can return NaN

val log1p : float -> float

let log1p: float => float;

natural logarithm of 1 + the argument, can return NaN, ES2015

val log10 : float -> float

let log10: float => float;

base 10 logarithm, can return NaN, ES2015

val log2 : float -> float

let log2: float => float;

base 2 logarithm, can return NaN, ES2015

val max_int : int -> int -> int

let max_int: int => int => int;

max value

val maxMany_int : int array -> int

let maxMany_int: array(int) => int;

max value

val max_float : float -> float -> float

let max_float: float => float => float;

max value

val maxMany_float : float array -> float

let maxMany_float: array(float) => float;

max value

val min_int : int -> int -> int

let min_int: int => int => int;

min value

val minMany_int : int array -> int

let minMany_int: array(int) => int;

min value

val min_float : float -> float -> float

let min_float: float => float => float;

min value

val minMany_float : float array -> float

let minMany_float: array(float) => float;

min value

val pow_float : base:float -> exp:float -> float

let pow_float: base:float => exp:float => float;

base to the power of the exponent

val random : unit -> float

let random: unit => float;

random number in [0,1)

val random_int : int -> int -> int

let random_int: int => int => int;

random number in [min,max)

val unsafe_round : float -> int

let unsafe_round: float => int;

rounds to nearest integer, returns a value not representable as int if NaN

val round : float -> float

let round: float => float;

rounds to nearest integer

val sign_int : int -> int

let sign_int: int => int;

the sign of the argument, 1, -1 or 0, ES2015

val sign_float : float -> float

let sign_float: float => float;

the sign of the argument, 1, -1, 0, -0 or NaN, ES2015

val sin : float -> float

let sin: float => float;

sine in radians

val sinh : float -> float

let sinh: float => float;

hyperbolic sine in radians, ES2015

val sqrt : float -> float

let sqrt: float => float;

square root, can return NaN

val tan : float -> float

let tan: float => float;

tangent in radians

val tanh : float -> float

let tanh: float => float;

hyperbolic tangent in radians, ES2015

val unsafe_trunc : float -> int

let unsafe_trunc: float => int;

truncate, ie. remove fractional digits, returns a value not representable as int if NaN, ES2015

val trunc : float -> float

let trunc: float => float;

truncate, ie. remove fractional digits, returns a value not representable as int if NaN, ES2015