accelerate-1.1.1.0: An embedded language for accelerated array processing

Copyright[2015..2017] Trevor L. McDonell
LicenseBSD3
MaintainerTrevor L. McDonell <tmcdonell@cse.unsw.edu.au>
Stabilityexperimental
Portabilitynon-portable (GHC extensions)
Safe HaskellNone
LanguageHaskell98

Data.Array.Accelerate.Data.Complex

Contents

Description

Complex numbers

Synopsis

Rectangular from

data Complex a :: * -> * #

Complex numbers are an algebraic type.

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.

The Foldable and Traversable instances traverse the real part first.

Constructors

~a :+ ~a infix 6

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

Instances

Monad Complex 

Methods

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

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

return :: a -> Complex a #

fail :: String -> Complex a #

Functor Complex 

Methods

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

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

Applicative Complex 

Methods

pure :: a -> Complex a #

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

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

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

Foldable Complex 

Methods

fold :: Monoid m => Complex m -> 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 #

Traversable 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) #

Generic1 Complex 

Associated Types

type Rep1 (Complex :: * -> *) :: * -> * #

Methods

from1 :: Complex a -> Rep1 Complex a #

to1 :: Rep1 Complex a -> Complex a #

Unbox a => Vector Vector (Complex a) 
Unbox a => MVector MVector (Complex a) 
Eq a => Eq (Complex a) 

Methods

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

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

RealFloat a => Floating (Complex a) 

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 #

RealFloat a => Fractional (Complex a) 

Methods

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

recip :: Complex a -> Complex a #

fromRational :: Rational -> Complex a #

Data a => Data (Complex a) 

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 :: (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) #

RealFloat a => Num (Complex a) 

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) 
Show a => Show (Complex a) 

Methods

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

show :: Complex a -> String #

showList :: [Complex a] -> ShowS #

Generic (Complex a) 

Associated Types

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

Methods

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

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

Storable a => Storable (Complex a) 

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 () #

NFData a => NFData (Complex a) 

Methods

rnf :: Complex a -> () #

Unbox a => Unbox (Complex a) 
type Rep1 Complex 
data MVector s (Complex a) 
data MVector s (Complex a) = MV_Complex (MVector s (a, a))
type Rep (Complex a) 
data Vector (Complex a) 
data Vector (Complex a) = V_Complex (Vector (a, a))
type Plain (Complex a) Source # 
type Plain (Complex a) = Complex (Plain a)

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 :: forall a. Floating a => Exp a -> Exp a -> Exp (Complex a) Source #

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

cis :: forall a. 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

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.

Conjugate

conjugate :: Num a => Exp (Complex a) -> Exp (Complex a) Source #

Return the complex conjugate of a complex number, defined as

conjugate(Z) = X - iY

Orphan instances

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

Methods

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

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

Methods

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

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

Associated Types

type Plain (Complex a) :: * Source #

Methods

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

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

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 => Fractional (Exp (Complex a)) Source # 

Methods

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

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

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

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

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) #

Elt a => Elt (Complex a) Source # 

Methods

eltType :: Complex a -> TupleType (EltRepr (Complex a))

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

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

Eq a => Eq (Complex a) Source # 

Methods

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

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