Previous  Up  Next

Module Complex


module Complex: Extlib.ExtComplex.Complex
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(s): Xavier Leroy (base module), Gabriel Scherer, David Teller

type t = t = {
   re : float;
   im : float;
}
The type of complex numbers. re is the real part and im the imaginary part.
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 Numeric.numeric
val inv : t -> t
inv x returns the value of 1/x
val succ : t -> t
Add Complex.one to this number.
val pred : t -> t
Remove Complex.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 of_int : int -> t
val to_int : t -> int
val of_string : string -> t
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 -> bool
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (=) : t -> t -> bool

Boilerplate code


S-Expressions

val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val print : 'a Extlib.InnerIO.output -> t -> unit
Printing