
Number.Complex  Portability  portable (?)  Stability  provisional  Maintainer  numericprelude@henningthielemann.de 





Description 
Complex numbers.


Synopsis 




Cartesian form



Complex numbers are an algebraic type.
 Instances  C T  C a b => C a (T b)  C a b => C a (T b)  (C a, Sqr a b) => C a (T b)  Sqr a b => Sqr a (T b)  (Ord a, C a v) => C a (T v)  (C a, C a v) => C a (T v)  (Show v, C v, C v, C a v) => C a (T v)  Eq a => Eq (T a)  (C a, Eq a, Show a, Divisible a) => Fractional (T a)  (C a, Eq a, Show a) => Num (T a)  Read a => Read (T a)  Show a => Show (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  (Ord a, C a) => C (T a)  (Ord a, C a, C a) => C (T a)  Divisible a => C (T a)  (Polar a, C a, C a, Divisible a, Power a) => C (T a)  (Polar a, C a, C a, Divisible a, Power a) => C (T a) 






Construct a complex number from real and imaginary part.



Construct a complex number with negated imaginary part.


Polar form



Form a complex number from polar components of magnitude and phase.



cis t is a complex value with magnitude 1
and phase t (modulo 2*pi).



Scale a complex number to magnitude 1.
For a complex number z, abs z is a number with the magnitude of z,
but oriented in the positive real direction, whereas signum z
has the phase of z, but unit magnitude.



Minimal implementation: toPolar or (magnitude and phase),
usually the instance definition
magnitude = defltMagnitude
phase = defltPhase
is enough.
This class requires transcendent number types
although magnitude can be computed algebraically.
  Methods   The function toPolar takes a complex number and
returns a (magnitude, phase) pair in canonical form:
the magnitude is nonnegative, and the phase in the range (pi, pi];
if the magnitude is zero, then so is the phase.
    
  Instances  





The phase of a complex number, in the range (pi, pi].
If the magnitude is zero, then so is the phase.


Conjugate



The conjugate of a complex number.


Properties




Auxiliary classes


class C a => Divisible a where  Source 

In order to have an efficient implementation
for both complex floats and exact complex numbers,
we define the intermediate class Complex.Divisible
which in fact implements the complex division.
This way we avoid overlapping and undecidable instances.
In most cases it should suffice to define
an instance of Complex.Divisible with no method implementation
for each instance of Fractional.
  Methods    Instances  





We like to build the Complex Algebraic instance
on top of the Algebraic instance of the scalar type.
This poses no problem to sqrt.
However, Number.Complex.root requires computing the complex argument
which is a transcendent operation.
In order to keep the type class dependencies clean
for more sophisticated algebraic number types,
we introduce a type class which actually performs the radix operation.
  Methods    Instances  




Produced by Haddock version 2.6.0 