numeric-prelude-0.0.2: An experimental alternative hierarchy of numeric type classesSource codeContentsIndex
Number.Complex
Portabilityportable (?)
Stabilityprovisional
Maintainernumericprelude@henning-thielemann.de
Contents
Cartesian form
Polar form
Conjugate
Properties
Auxiliary classes
Description
Complex numbers.
Synopsis
data T a
fromReal :: C a => a -> T a
(+:) :: a -> a -> T a
(-:) :: C a => a -> a -> T a
fromPolar :: C a => a -> a -> T a
cis :: C a => a -> T a
signum :: (C a, C a a, C a) => T a -> T a
class C a => Polar a where
toPolar :: T a -> (a, a)
magnitude :: T a -> a
phase :: T a -> a
defltMagnitude :: C a => T a -> a
defltPhase :: (C a, C a) => T a -> a
conjugate :: C a => T a -> T a
propPolar :: (Polar a, C a) => T a -> Bool
class C a => Divisible a where
divide :: T a -> T a -> T a
defltDiv :: C a => T a -> T a -> T a
class C a => Power a where
power :: Rational -> T a -> T a
defltPow :: (Polar a, C a) => Rational -> T a -> T a
Cartesian form
data T a Source
Complex numbers are an algebraic type.
show/hide 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)
fromReal :: C a => a -> T aSource
(+:) :: a -> a -> T aSource
Construct a complex number from real and imaginary part.
(-:) :: C a => a -> a -> T aSource
Construct a complex number with negated imaginary part.
Polar form
fromPolar :: C a => a -> a -> T aSource
Form a complex number from polar components of magnitude and phase.
cis :: C a => a -> T aSource
cis t is a complex value with magnitude 1 and phase t (modulo 2*pi).
signum :: (C a, C a a, C a) => T a -> T aSource

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.

class C a => Polar a whereSource

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
toPolar :: T a -> (a, a)Source
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.
magnitude :: T a -> aSource
phase :: T a -> aSource
show/hide Instances
defltMagnitude :: C a => T a -> aSource
defltPhase :: (C a, C a) => T a -> aSource
The phase of a complex number, in the range (-pi, pi]. If the magnitude is zero, then so is the phase.
Conjugate
conjugate :: C a => T a -> T aSource
The conjugate of a complex number.
Properties
propPolar :: (Polar a, C a) => T a -> BoolSource
Auxiliary classes
class C a => Divisible a whereSource
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
divide :: T a -> T a -> T aSource
show/hide Instances
defltDiv :: C a => T a -> T a -> T aSource
class C a => Power a whereSource
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
power :: Rational -> T a -> T aSource
show/hide Instances
defltPow :: (Polar a, C a) => Rational -> T a -> T aSource
Produced by Haddock version 2.6.0