Module Complex

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.