module Complex: BatComplex
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 =Complex.t= {
|
re : |
|
im : |
val zero : t0.val one : t1.val i : ti.val neg : t -> tval conj : t -> tx + i.y, returns x - i.y.val add : t -> t -> tval sub : t -> t -> tval mul : t -> t -> tval inv : t -> t1/z).val div : t -> t -> tval sqrt : t -> tx + 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 -> floatx + i.y, returns x^2 + y^2.val norm : t -> floatx + i.y, returns sqrt(x^2 + y^2).val arg : t -> float-pi to pi. This function has a discontinuity along the
negative real axis.val polar : float -> float -> tpolar norm arg returns the complex having norm norm
and argument arg.val exp : t -> texp z returns e to the z power.val log : t -> te).val pow : t -> t -> tpow z1 z2 returns z1 to the z2 power.val operations : t BatNumber.numeric
val inv : t -> tinv x returns the value of 1/xval succ : t -> tBatComplex.one to this number.val pred : t -> tBatComplex.one from this number.val abs : t -> tabs 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 -> intto_int c is the integer part of the real part of cval of_string : string -> tof_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 -> tComplex.of_float x returns the complex number x+0ival to_float : t -> floatComplex.to_float (a+bi) returns the float amodule Infix:BatNumber.Infixwith type bat__infix_t = t
module Compare:BatNumber.Comparewith type bat__compare_t = t
val print : 'a BatInnerIO.output -> t -> unit