# Module Batteries.Complex

    module Complex: BatComplex

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 = Complex.t = {

`` | `re : `float`;`
`` | `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 inv : t -> t

Multiplicative inverse (`1/z`).

    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 pow : t -> t -> t

Power function. `pow z1 z2` returns `z1` to the `z2` power.

    val operations : t BatNumber.numeric

    val inv : t -> t

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

    val succ : t -> t

Add `BatComplex.one` to this number.

    val pred : t -> t

Remove `BatComplex.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