Below is the API for the OCaml standard library. It's directly copied over from the OCaml Manual, formatted to the Reason syntax and styled accordingly. The API docs are work-in-progress; we'll be polishing these gradually!

If you're targeting JavaScript, the API docs for BuckleScript includes all of below, plus JS-specific APIs.

`module Complex: sig .. end`

Complex numbers.

This module provides arithmetic operations on complex numbers.
Complex numbers are represented by their real and imaginary parts
(cartesian representation). Each part is represented by a
double-precision floating-point number (type `float`

).

`type t = {`

` ` |
`re : float;` |

` ` |
`im : float;` |

The type of complex numbers.

`re`

is the real part and `im`

the
imaginary part.```
let zero: t;
```

The complex number

`0`

.```
let one: t;
```

The complex number

`1`

.```
let i: t;
```

The complex number

`i`

.```
let neg: t => t;
```

Unary negation.

```
let conj: t => t;
```

Conjugate: given the complex

`x + i.y`

, returns `x - i.y`

.```
let add: (t, t) => t;
```

Addition

```
let sub: (t, t) => t;
```

Subtraction

```
let mul: (t, t) => t;
```

Multiplication

```
let inv: t => t;
```

Multiplicative inverse (

`1/z`

).```
let div: (t, t) => t;
```

Division

```
let sqrt: t => t;
```

Square root. The result

`x + i.y`

is such that `x > 0`

or
`x = 0`

and `y >= 0`

.
This function has a discontinuity along the negative real axis.```
let norm2: t => float;
```

Norm squared: given

`x + i.y`

, returns `x^2 + y^2`

.```
let norm: t => float;
```

Norm: given

`x + i.y`

, returns `sqrt(x^2 + y^2)`

.```
let arg: t => float;
```

Argument. The argument of a complex number is the angle
in the complex plane between the positive real axis and a line
passing through zero and the number. This angle ranges from

`-pi`

to `pi`

. This function has a discontinuity along the
negative real axis.```
let polar: (float, float) => t;
```

`polar norm arg`

returns the complex having norm `norm`

and argument `arg`

.```
let exp: t => t;
```

Exponentiation.

`exp z`

returns `e`

to the `z`

power.```
let log: t => t;
```

Natural logarithm (in base

`e`

).```
let pow: (t, t) => t;
```

Power function.

`pow z1 z2`

returns `z1`

to the `z2`

power.