module BatComplex:sig
..end
Additional and modified functions for complex numbers.
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
).
typet =
Stdlib.Complex.t
= {
|
re : |
|
im : |
}
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 =
and
0y >= 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
module Infix:BatNumber.Infix
with type bat__infix_t = t
module Compare:BatNumber.Compare
with type bat__compare_t = t
val print : 'a BatInnerIO.output -> t -> unit