Previous  Up  Next

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 = Stdlib.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