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`).

- author Xavier Leroy (base module)

- author Gabriel Scherer

- author David Teller

`type t = Stdlib.Complex.t = {`

1. `re : float;`
2. `im : float;`

`}`
`val zero : t`

The complex number `0`.

`val one : t`

The complex number `1`.

`val i : t`

The complex number `i`.

`val neg : t -> t`

Unary negation.

`val conj : t -> t`

Conjugate: given the complex `x + i.y`, returns `x - i.y`.

`val add : t -> t -> t`

Addition

`val sub : t -> t -> t`

Subtraction

`val mul : t -> t -> t`

Multiplication

`val div : t -> t -> t`

Division

`val 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.

`val norm2 : t -> float`

Norm squared: given `x + i.y`, returns `x^2 + y^2`.

`val norm : t -> float`

Norm: given `x + i.y`, returns `sqrt(x^2 + y^2)`.

`val 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.

`val polar : float -> float -> t`

`polar norm arg` returns the complex having norm `norm` and argument `arg`.

`val exp : t -> t`

Exponentiation. `exp z` returns `e` to the `z` power.

`val log : t -> t`

Natural logarithm (in base `e`).

`val operations : t BatNumber.numeric`
`val inv : t -> t`

`inv x` returns the value of `1/x`

`val succ : t -> t`

Add `one` to this number.

`val pred : t -> t`

Remove `one` from this number.

`val abs : t -> t`

`abs c` returns the module of this complex number, i.e. `abs c = Float.sqrt((re c) *. (re c) +. (im c) *. (im c) )`

`val modulo : t -> t -> t`
`val pow : t -> t -> t`
`val compare : t -> t -> int`
`val ord : t -> t -> BatOrd.order`
`val equal : t -> t -> bool`
`val of_int : int -> t`
`val to_int : t -> int`

`to_int c` is the integer part of the real part of `c`

`val of_string : string -> t`

`of_string s` accepts strings with the following formats:

(<int>|<float>) (+|-) i ( * | . | ) (<int>|<float>)

where (a|b|c) is either a or b or c.

In addition the following degenerate formats are also accepted:

(+|-) i ( * | . | ) (<int>|<float>)

(<int>|<float>) (+|-) i

(<int>|<float>)

`val to_string : t -> string`
`val (+) : t -> t -> t`
`val (-) : t -> t -> t`
`val (*) : t -> t -> t`
`val (/) : t -> t -> t`
`val (**) : t -> t -> t`
`val (--) : t -> t -> t BatEnum.t`
`val (---) : t -> t -> t BatEnum.t`
`val of_float : float -> t`

`Complex.of_float x` returns the complex number `x+0i`

`val to_float : t -> float`

`Complex.to_float (a+bi)` returns the float `a`

## Submodules grouping all infix operators

`module Infix : BatNumber.Infix with type bat__infix_t = t`
`module Compare : BatNumber.Compare with type bat__compare_t = t`

## Boilerplate code

`val print : 'a BatInnerIO.output -> t -> unit`

Printing