Copyright	[2015..2020] The Accelerate Team
License	BSD3
Maintainer	Trevor L. McDonell <trevor.mcdonell@gmail.com>
Stability	experimental
Portability	non-portable (GHC extensions)
Safe Haskell	None
Language	Haskell2010

Data.Array.Accelerate.Data.Complex

Contents

Rectangular from
Polar form
Conjugate
Orphan instances

Description

Complex numbers, stored in the usual C-style array-of-struct representation, for easy interoperability.

Synopsis

data Complex a = !a :+ !a
pattern (::+) :: Elt a => Exp a -> Exp a -> Exp (Complex a)
real :: Elt a => Exp (Complex a) -> Exp a
imag :: Elt a => Exp (Complex a) -> Exp a
mkPolar :: Floating a => Exp a -> Exp a -> Exp (Complex a)
cis :: Floating a => Exp a -> Exp (Complex a)
polar :: RealFloat a => Exp (Complex a) -> Exp (a, a)
magnitude :: RealFloat a => Exp (Complex a) -> Exp a
magnitude' :: RealFloat a => Exp (Complex a) -> Exp a
phase :: RealFloat a => Exp (Complex a) -> Exp a
conjugate :: Num a => Exp (Complex a) -> Exp (Complex a)

Rectangular from

data Complex a #

A data type representing complex numbers.

You can read about complex numbers on wikipedia.

In haskell, complex numbers are represented as a :+ b which can be thought of as representing $a + bi$. 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. Apart from the loss of precision due to IEEE754 floating point numbers, it holds that z == abs z * signum z.

Note that Complex's instances inherit the deficiencies from the type parameter's. For example, Complex Float's Ord instance has similar problems to Float's.

As can be seen in the examples, the Foldable and Traversable instances traverse the real part first.

Examples

Expand

>>> (5.0 :+ 2.5) + 6.5
11.5 :+ 2.5

>>> abs (1.0 :+ 1.0) - sqrt 2.0
0.0 :+ 0.0

>>> abs (signum (4.0 :+ 3.0))
1.0 :+ 0.0

>>> foldr (:) [] (1 :+ 2)
[1,2]

>>> mapM print (1 :+ 2)
1
2

Constructors

!a :+ !a infix 6

forms a complex number from its real and imaginary rectangular components.

Instances

Instances details

Functor Complex Source #

Since: 1.2.0.0

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

fmap :: (Elt a, Elt b, Elt (Complex a), Elt (Complex b)) => (Exp a -> Exp b) -> Exp (Complex a) -> Exp (Complex b) Source #

(<$) :: (Elt a, Elt b, Elt (Complex a), Elt (Complex b)) => Exp a -> Exp (Complex b) -> Exp (Complex a) Source #

MonadFix Complex

Since: base-4.15.0.0

Instance details

Defined in Data.Complex

Methods

mfix :: (a -> Complex a) -> Complex a #

MonadZip Complex

Since: base-4.15.0.0

Instance details

Defined in Data.Complex

Methods

mzip :: Complex a -> Complex b -> Complex (a, b) #

mzipWith :: (a -> b -> c) -> Complex a -> Complex b -> Complex c #

munzip :: Complex (a, b) -> (Complex a, Complex b) #

Foldable Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

Methods

fold :: Monoid m => Complex m -> m #

foldMap :: Monoid m => (a -> m) -> Complex a -> m #

foldMap' :: Monoid m => (a -> m) -> Complex a -> m #

foldr :: (a -> b -> b) -> b -> Complex a -> b #

foldr' :: (a -> b -> b) -> b -> Complex a -> b #

foldl :: (b -> a -> b) -> b -> Complex a -> b #

foldl' :: (b -> a -> b) -> b -> Complex a -> b #

foldr1 :: (a -> a -> a) -> Complex a -> a #

foldl1 :: (a -> a -> a) -> Complex a -> a #

toList :: Complex a -> [a] #

null :: Complex a -> Bool #

length :: Complex a -> Int #

elem :: Eq a => a -> Complex a -> Bool #

maximum :: Ord a => Complex a -> a #

minimum :: Ord a => Complex a -> a #

sum :: Num a => Complex a -> a #

product :: Num a => Complex a -> a #

Foldable1 Complex

Since: base-4.18.0.0

Instance details

Defined in Data.Foldable1

Methods

fold1 :: Semigroup m => Complex m -> m #

foldMap1 :: Semigroup m => (a -> m) -> Complex a -> m #

foldMap1' :: Semigroup m => (a -> m) -> Complex a -> m #

toNonEmpty :: Complex a -> NonEmpty a #

maximum :: Ord a => Complex a -> a #

minimum :: Ord a => Complex a -> a #

head :: Complex a -> a #

last :: Complex a -> a #

foldrMap1 :: (a -> b) -> (a -> b -> b) -> Complex a -> b #

foldlMap1' :: (a -> b) -> (b -> a -> b) -> Complex a -> b #

foldlMap1 :: (a -> b) -> (b -> a -> b) -> Complex a -> b #

foldrMap1' :: (a -> b) -> (a -> b -> b) -> Complex a -> b #

Eq1 Complex

>>> eq1 (1 :+ 2) (1 :+ 2)
True

>>> eq1 (1 :+ 2) (1 :+ 3)
False

Since: base-4.16.0.0

Instance details

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Complex a -> Complex b -> Bool #

Read1 Complex

>>> readPrec_to_S readPrec1 0 "(2 % 3) :+ (3 % 4)" :: [(Complex Rational, String)]
[(2 % 3 :+ 3 % 4,"")]

Since: base-4.16.0.0

Instance details

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Complex a) #

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Complex a] #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Complex a) #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Complex a] #

Show1 Complex

>>> showsPrec1 0 (2 :+ 3) ""
"2 :+ 3"

Since: base-4.16.0.0

Instance details

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Complex a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Complex a] -> ShowS #

Traversable Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) #

sequenceA :: Applicative f => Complex (f a) -> f (Complex a) #

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) #

sequence :: Monad m => Complex (m a) -> m (Complex a) #

Applicative Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

Methods

pure :: a -> Complex a #

(<*>) :: Complex (a -> b) -> Complex a -> Complex b #

liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c #

(*>) :: Complex a -> Complex b -> Complex b #

(<*) :: Complex a -> Complex b -> Complex a #

Functor Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

Methods

fmap :: (a -> b) -> Complex a -> Complex b #

(<$) :: a -> Complex b -> Complex a #

Monad Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

Methods

(>>=) :: Complex a -> (a -> Complex b) -> Complex b #

(>>) :: Complex a -> Complex b -> Complex b #

return :: a -> Complex a #

Hashable1 Complex

Instance details

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Complex a -> Int

Generic1 Complex

Instance details

Defined in Data.Complex

Associated Types

type Rep1 Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex type Rep1 Complex = D1 ('MetaData "Complex" "Data.Complex" "base" 'False) (C1 ('MetaCons ":+" ('InfixI 'NotAssociative 6) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) Par1))

Methods

from1 :: Complex a -> Rep1 Complex a #

to1 :: Rep1 Complex a -> Complex a #

(FromIntegral a b, Num b, Elt (Complex b)) => FromIntegral a (Complex b) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

fromIntegral :: Exp a -> Exp (Complex b) Source #

(Lift Exp a, Elt (Plain a)) => Lift Exp (Complex a) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Associated Types

type Plain (Complex a)
Instance details Defined in Data.Array.Accelerate.Data.Complex type Plain (Complex a) = Complex (Plain a)

Methods

lift :: Complex a -> Exp (Plain (Complex a)) Source #

Elt a => Unlift Exp (Complex (Exp a)) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

unlift :: Exp (Plain (Complex (Exp a))) -> Complex (Exp a) Source #

Unbox a => Vector Vector (Complex a)

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Complex a) -> ST s (Vector (Complex a))

basicUnsafeThaw :: Vector (Complex a) -> ST s (Mutable Vector s (Complex a))

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Vector (Complex a) -> Int -> Box (Complex a)

basicUnsafeCopy :: Mutable Vector s (Complex a) -> Vector (Complex a) -> ST s ()

elemseq :: Vector (Complex a) -> Complex a -> b -> b

Unbox a => MVector MVector (Complex a)

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a)

basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Complex a))

basicInitialize :: MVector s (Complex a) -> ST s ()

basicUnsafeReplicate :: Int -> Complex a -> ST s (MVector s (Complex a))

basicUnsafeRead :: MVector s (Complex a) -> Int -> ST s (Complex a)

basicUnsafeWrite :: MVector s (Complex a) -> Int -> Complex a -> ST s ()

basicClear :: MVector s (Complex a) -> ST s ()

basicSet :: MVector s (Complex a) -> Complex a -> ST s ()

basicUnsafeCopy :: MVector s (Complex a) -> MVector s (Complex a) -> ST s ()

basicUnsafeMove :: MVector s (Complex a) -> MVector s (Complex a) -> ST s ()

basicUnsafeGrow :: MVector s (Complex a) -> Int -> ST s (MVector s (Complex a))

Eq a => Eq (Complex a) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

(==) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool Source #

(/=) :: Exp (Complex a) -> Exp (Complex a) -> Exp Bool Source #

Elt a => Elt (Complex a) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

eltR :: TypeR (EltR (Complex a))

tagsR :: [TagR (EltR (Complex a))]

fromElt :: Complex a -> EltR (Complex a)

toElt :: EltR (Complex a) -> Complex a

Data a => Data (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) #

toConstr :: Complex a -> Constr #

dataTypeOf :: Complex a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) #

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

Storable a => Storable (Complex a)

Since: base-4.8.0.0

Instance details

Defined in Data.Complex

Methods

sizeOf :: Complex a -> Int #

alignment :: Complex a -> Int #

peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) #

pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Complex a) #

pokeByteOff :: Ptr b -> Int -> Complex a -> IO () #

peek :: Ptr (Complex a) -> IO (Complex a) #

poke :: Ptr (Complex a) -> Complex a -> IO () #

RealFloat a => Floating (Exp (Complex a)) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

pi :: Exp (Complex a) #

exp :: Exp (Complex a) -> Exp (Complex a) #

log :: Exp (Complex a) -> Exp (Complex a) #

sqrt :: Exp (Complex a) -> Exp (Complex a) #

(**) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) #

logBase :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) #

sin :: Exp (Complex a) -> Exp (Complex a) #

cos :: Exp (Complex a) -> Exp (Complex a) #

tan :: Exp (Complex a) -> Exp (Complex a) #

asin :: Exp (Complex a) -> Exp (Complex a) #

acos :: Exp (Complex a) -> Exp (Complex a) #

atan :: Exp (Complex a) -> Exp (Complex a) #

sinh :: Exp (Complex a) -> Exp (Complex a) #

cosh :: Exp (Complex a) -> Exp (Complex a) #

tanh :: Exp (Complex a) -> Exp (Complex a) #

asinh :: Exp (Complex a) -> Exp (Complex a) #

acosh :: Exp (Complex a) -> Exp (Complex a) #

atanh :: Exp (Complex a) -> Exp (Complex a) #

log1p :: Exp (Complex a) -> Exp (Complex a) #

expm1 :: Exp (Complex a) -> Exp (Complex a) #

log1pexp :: Exp (Complex a) -> Exp (Complex a) #

log1mexp :: Exp (Complex a) -> Exp (Complex a) #

RealFloat a => Floating (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

pi :: Complex a #

exp :: Complex a -> Complex a #

log :: Complex a -> Complex a #

sqrt :: Complex a -> Complex a #

(**) :: Complex a -> Complex a -> Complex a #

logBase :: Complex a -> Complex a -> Complex a #

sin :: Complex a -> Complex a #

cos :: Complex a -> Complex a #

tan :: Complex a -> Complex a #

asin :: Complex a -> Complex a #

acos :: Complex a -> Complex a #

atan :: Complex a -> Complex a #

sinh :: Complex a -> Complex a #

cosh :: Complex a -> Complex a #

tanh :: Complex a -> Complex a #

asinh :: Complex a -> Complex a #

acosh :: Complex a -> Complex a #

atanh :: Complex a -> Complex a #

log1p :: Complex a -> Complex a #

expm1 :: Complex a -> Complex a #

log1pexp :: Complex a -> Complex a #

log1mexp :: Complex a -> Complex a #

Generic (Complex a)

Instance details

Defined in Data.Complex

Associated Types

type Rep (Complex a)	Since: base-4.9.0.0
Instance details Defined in Data.Complex type Rep (Complex a) = D1 ('MetaData "Complex" "Data.Complex" "base" 'False) (C1 ('MetaCons ":+" ('InfixI 'NotAssociative 6) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a)))

Methods

from :: Complex a -> Rep (Complex a) x #

to :: Rep (Complex a) x -> Complex a #

RealFloat a => Num (Exp (Complex a)) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

(+) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) #

(-) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) #

(*) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) #

negate :: Exp (Complex a) -> Exp (Complex a) #

abs :: Exp (Complex a) -> Exp (Complex a) #

signum :: Exp (Complex a) -> Exp (Complex a) #

fromInteger :: Integer -> Exp (Complex a) #

RealFloat a => Num (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

(+) :: Complex a -> Complex a -> Complex a #

(-) :: Complex a -> Complex a -> Complex a #

(*) :: Complex a -> Complex a -> Complex a #

negate :: Complex a -> Complex a #

abs :: Complex a -> Complex a #

signum :: Complex a -> Complex a #

fromInteger :: Integer -> Complex a #

Read a => Read (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

readsPrec :: Int -> ReadS (Complex a) #

readList :: ReadS [Complex a] #

readPrec :: ReadPrec (Complex a) #

readListPrec :: ReadPrec [Complex a] #

RealFloat a => Fractional (Exp (Complex a)) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

Methods

(/) :: Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a) #

recip :: Exp (Complex a) -> Exp (Complex a) #

fromRational :: Rational -> Exp (Complex a) #

RealFloat a => Fractional (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

(/) :: Complex a -> Complex a -> Complex a #

recip :: Complex a -> Complex a #

fromRational :: Rational -> Complex a #

Show a => Show (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

showsPrec :: Int -> Complex a -> ShowS #

show :: Complex a -> String #

showList :: [Complex a] -> ShowS #

NFData a => NFData (Complex a)

Instance details

Defined in Control.DeepSeq

Methods

rnf :: Complex a -> () #

Eq a => Eq (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

(==) :: Complex a -> Complex a -> Bool #

(/=) :: Complex a -> Complex a -> Bool #

Hashable a => Hashable (Complex a)

Instance details

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Complex a -> Int

hash :: Complex a -> Int

Prim a => Prim (Complex a)

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Complex a) -> Int#

sizeOf# :: Complex a -> Int#

alignmentOfType# :: Proxy (Complex a) -> Int#

alignment# :: Complex a -> Int#

indexByteArray# :: ByteArray# -> Int# -> Complex a

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Complex a #)

writeByteArray# :: MutableByteArray# s -> Int# -> Complex a -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Complex a -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Complex a

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Complex a #)

writeOffAddr# :: Addr# -> Int# -> Complex a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Complex a -> State# s -> State# s

Unbox a => Unbox (Complex a)

Instance details

Defined in Data.Vector.Unboxed.Base

Each (Complex a) (Complex b) a b

Instance details

Defined in Lens.Micro.Internal

Methods

each :: Traversal (Complex a) (Complex b) a b

type Rep1 Complex

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

type Rep1 Complex = D1 ('MetaData "Complex" "Data.Complex" "base" 'False) (C1 ('MetaCons ":+" ('InfixI 'NotAssociative 6) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) Par1))

newtype MVector s (Complex a)

Instance details

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Complex a) = MV_Complex (MVector s (a, a))

type Plain (Complex a) Source #

Instance details

Defined in Data.Array.Accelerate.Data.Complex

type Plain (Complex a) = Complex (Plain a)

type Rep (Complex a)

Since: base-4.9.0.0

Instance details

Defined in Data.Complex

type Rep (Complex a) = D1 ('MetaData "Complex" "Data.Complex" "base" 'False) (C1 ('MetaCons ":+" ('InfixI 'NotAssociative 6) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a)))

newtype Vector (Complex a)

Instance details

Defined in Data.Vector.Unboxed.Base

newtype Vector (Complex a) = V_Complex (Vector (a, a))

pattern (::+) :: Elt a => Exp a -> Exp a -> Exp (Complex a) infix 6 Source #

real :: Elt a => Exp (Complex a) -> Exp a Source #

Return the real part of a complex number

imag :: Elt a => Exp (Complex a) -> Exp a Source #

Return the imaginary part of a complex number

Polar form

mkPolar :: Floating a => Exp a -> Exp a -> Exp (Complex a) Source #

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

cis :: Floating a => Exp a -> Exp (Complex a) Source #

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

polar :: RealFloat a => Exp (Complex a) -> Exp (a, a) Source #

The function polar takes a complex number and returns a (magnitude, phase) pair in canonical form: the magnitude is non-negative, and the phase in the range (-pi, pi]; if the magnitude is zero, then so is the phase.

magnitude :: RealFloat a => Exp (Complex a) -> Exp a Source #

The non-negative magnitude of a complex number

magnitude' :: RealFloat a => Exp (Complex a) -> Exp a Source #

As magnitude, but ignore floating point rounding and use the traditional (simpler to evaluate) definition.

Since: 1.3.0.0

phase :: RealFloat a => Exp (Complex a) -> Exp a Source #

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