Data.Array.Knead.Expression

Documentation

data Exp a

Instances

Value Exp

Defined in LLVM.DSL.Expression

Methods

lift0 :: T a -> Exp a

lift1 :: (T a -> T b) -> Exp a -> Exp b

lift2 :: (T a -> T b -> T c) -> Exp a -> Exp b -> Exp c

(Transcendental a, Real a, RationalConstant a) => Floating (Exp a)

Defined in LLVM.DSL.Expression

Methods

pi :: Exp a

exp :: Exp a -> Exp a

log :: Exp a -> Exp a

sqrt :: Exp a -> Exp a

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

logBase :: Exp a -> Exp a -> Exp a

sin :: Exp a -> Exp a

cos :: Exp a -> Exp a

tan :: Exp a -> Exp a

asin :: Exp a -> Exp a

acos :: Exp a -> Exp a

atan :: Exp a -> Exp a

sinh :: Exp a -> Exp a

cosh :: Exp a -> Exp a

tanh :: Exp a -> Exp a

asinh :: Exp a -> Exp a

acosh :: Exp a -> Exp a

atanh :: Exp a -> Exp a

log1p :: Exp a -> Exp a

expm1 :: Exp a -> Exp a

log1pexp :: Exp a -> Exp a

log1mexp :: Exp a -> Exp a

(PseudoRing a, Real a, IntegerConstant a) => Num (Exp a)

Defined in LLVM.DSL.Expression

Methods

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

(-) :: Exp a -> Exp a -> Exp a

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

negate :: Exp a -> Exp a

abs :: Exp a -> Exp a

signum :: Exp a -> Exp a

fromInteger :: Integer -> Exp a

(Field a, Real a, RationalConstant a) => Fractional (Exp a)

Defined in LLVM.DSL.Expression

Methods

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

recip :: Exp a -> Exp a

fromRational :: Rational -> Exp a

Compose (Exp a)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (Exp a)

Methods

compose :: Exp a -> Exp (Composed (Exp a))

(Real a, PseudoRing a, IntegerConstant a) => C (Exp a)

Defined in LLVM.DSL.Expression

Methods

abs :: Exp a -> Exp a

signum :: Exp a -> Exp a

Additive a => C (Exp a)

We do not require a numeric prelude superclass, thus also LLVM only types like vectors are instances.

Defined in LLVM.DSL.Expression

Methods

zero :: Exp a

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

(-) :: Exp a -> Exp a -> Exp a

negate :: Exp a -> Exp a

(Transcendental a, RationalConstant a) => C (Exp a)

Defined in LLVM.DSL.Expression

Methods

sqrt :: Exp a -> Exp a

root :: Integer -> Exp a -> Exp a

(^/) :: Exp a -> Rational -> Exp a

(Field a, RationalConstant a) => C (Exp a)

Defined in LLVM.DSL.Expression

Methods

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

recip :: Exp a -> Exp a

fromRational' :: Rational -> Exp a

(^-) :: Exp a -> Integer -> Exp a

(PseudoRing a, IntegerConstant a) => C (Exp a)

Defined in LLVM.DSL.Expression

Methods

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

one :: Exp a

fromInteger :: Integer -> Exp a

(^) :: Exp a -> Integer -> Exp a

(Transcendental a, RationalConstant a) => C (Exp a)

Defined in LLVM.DSL.Expression

Methods

pi :: Exp a

exp :: Exp a -> Exp a

log :: Exp a -> Exp a

logBase :: Exp a -> Exp a -> Exp a

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

sin :: Exp a -> Exp a

cos :: Exp a -> Exp a

tan :: Exp a -> Exp a

asin :: Exp a -> Exp a

acos :: Exp a -> Exp a

atan :: Exp a -> Exp a

sinh :: Exp a -> Exp a

cosh :: Exp a -> Exp a

tanh :: Exp a -> Exp a

asinh :: Exp a -> Exp a

acosh :: Exp a -> Exp a

atanh :: Exp a -> Exp a

Aggregate (Exp a) (T a)

Defined in LLVM.DSL.Expression

Associated Types

type MultiValuesOf (Exp a)

type ExpressionsOf (T a)

Methods

bundle :: Exp a -> CodeGenFunction r (T a)

dissect :: T a -> Exp a

(a ~ Scalar v, PseudoModule v, IntegerConstant a) => C (Exp a) (Exp v)

Defined in LLVM.DSL.Expression

Methods

(*>) :: Exp a -> Exp v -> Exp v

type Composed (Exp a)

Defined in LLVM.DSL.Expression

type Composed (Exp a) = a

type MultiValuesOf (Exp a)

Defined in LLVM.DSL.Expression

type MultiValuesOf (Exp a) = T a

class Value (val :: Type -> Type)

Minimal complete definition

lift0, lift1, lift2

Instances

Value Exp

Defined in LLVM.DSL.Expression

Methods

lift0 :: T a -> Exp a

lift1 :: (T a -> T b) -> Exp a -> Exp b

lift2 :: (T a -> T b -> T c) -> Exp a -> Exp b -> Exp c

Value T

Defined in LLVM.DSL.Expression

Methods

lift0 :: T a -> T a

lift1 :: (T a -> T b) -> T a -> T b

lift2 :: (T a -> T b -> T c) -> T a -> T b -> T c

lift0 :: Value val => T a -> val a

lift1 :: Value val => (T a -> T b) -> val a -> val b

lift2 :: Value val => (T a -> T b -> T c) -> val a -> val b -> val c

lift3 :: Value val => (T a -> T b -> T c -> T d) -> val a -> val b -> val c -> val d

lift4 :: Value val => (T a -> T b -> T c -> T d -> T e) -> val a -> val b -> val c -> val d -> val e

liftM :: Aggregate ae am => (forall r. am -> CodeGenFunction r (T b)) -> ae -> Exp b

liftM2 :: (Aggregate ae am, Aggregate be bm) => (forall r. am -> bm -> CodeGenFunction r (T c)) -> ae -> be -> Exp c

liftM3 :: (Aggregate ae am, Aggregate be bm, Aggregate ce cm) => (forall r. am -> bm -> cm -> CodeGenFunction r (T d)) -> ae -> be -> ce -> Exp d

unliftM1 :: (Aggregate ae am, Aggregate be bm) => (ae -> be) -> am -> CodeGenFunction r bm

unliftM2 :: (Aggregate ae am, Aggregate be bm, Aggregate ce cm) => (ae -> be -> ce) -> am -> bm -> CodeGenFunction r cm

unliftM3 :: (Aggregate ae am, Aggregate be bm, Aggregate ce cm, Aggregate de dm) => (ae -> be -> ce -> de) -> am -> bm -> cm -> CodeGenFunction r dm

liftReprM :: (forall r. Repr a -> CodeGenFunction r (Repr b)) -> Exp a -> Exp b

liftReprM2 :: (forall r. Repr a -> Repr b -> CodeGenFunction r (Repr c)) -> Exp a -> Exp b -> Exp c

liftReprM3 :: (forall r. Repr a -> Repr b -> Repr c -> CodeGenFunction r (Repr d)) -> Exp a -> Exp b -> Exp c -> Exp d

zip :: Value val => val a -> val b -> val (a, b)

zip3 :: Value val => val a -> val b -> val c -> val (a, b, c)

zip4 :: Value val => val a -> val b -> val c -> val d -> val (a, b, c, d)

unzip :: Value val => val (a, b) -> (val a, val b)

unzip3 :: Value val => val (a, b, c) -> (val a, val b, val c)

unzip4 :: Value val => val (a, b, c, d) -> (val a, val b, val c, val d)

fst :: Value val => val (a, b) -> val a

snd :: Value val => val (a, b) -> val b

mapFst :: (Exp a -> Exp b) -> Exp (a, c) -> Exp (b, c)

mapSnd :: (Exp b -> Exp c) -> Exp (a, b) -> Exp (a, c)

mapPair :: (Exp a0 -> Exp a1, Exp b0 -> Exp b1) -> Exp (a0, b0) -> Exp (a1, b1)

swap :: Value val => val (a, b) -> val (b, a)

curry :: (Exp (a, b) -> c) -> Exp a -> Exp b -> c

uncurry :: (Exp a -> Exp b -> c) -> Exp (a, b) -> c

fst3 :: Value val => val (a, b, c) -> val a

snd3 :: Value val => val (a, b, c) -> val b

thd3 :: Value val => val (a, b, c) -> val c

mapFst3 :: (Exp a0 -> Exp a1) -> Exp (a0, b, c) -> Exp (a1, b, c)

mapSnd3 :: (Exp b0 -> Exp b1) -> Exp (a, b0, c) -> Exp (a, b1, c)

mapThd3 :: (Exp c0 -> Exp c1) -> Exp (a, b, c0) -> Exp (a, b, c1)

mapTriple :: (Exp a0 -> Exp a1, Exp b0 -> Exp b1, Exp c0 -> Exp c1) -> Exp (a0, b0, c0) -> Exp (a1, b1, c1)

tuple :: Exp tuple -> Exp (Tuple tuple)

untuple :: Exp (Tuple tuple) -> Exp tuple

modifyMultiValue :: (Value val, Compose a, Decompose pattern, PatternTuple pattern ~ tuple) => pattern -> (Decomposed T pattern -> a) -> val tuple -> val (Composed a)

modifyMultiValue2 :: (Value val, Compose a, Decompose patternA, Decompose patternB, PatternTuple patternA ~ tupleA, PatternTuple patternB ~ tupleB) => patternA -> patternB -> (Decomposed T patternA -> Decomposed T patternB -> a) -> val tupleA -> val tupleB -> val (Composed a)

modifyMultiValueM :: (Compose a, Decompose pattern, PatternTuple pattern ~ tuple) => pattern -> (forall r. Decomposed T pattern -> CodeGenFunction r a) -> Exp tuple -> Exp (Composed a)

modifyMultiValueM2 :: (Compose a, Decompose patternA, Decompose patternB, PatternTuple patternA ~ tupleA, PatternTuple patternB ~ tupleB) => patternA -> patternB -> (forall r. Decomposed T patternA -> Decomposed T patternB -> CodeGenFunction r a) -> Exp tupleA -> Exp tupleB -> Exp (Composed a)

class Compose multituple where

Associated Types

type Composed multituple

Methods

compose :: multituple -> Exp (Composed multituple)

A nested zip.

Instances

Compose ()

Defined in LLVM.DSL.Expression

Associated Types

type Composed ()

Methods

compose :: () -> Exp (Composed ())

Compose a => Compose (Complex a)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (Complex a)

Methods

compose :: Complex a -> Exp (Composed (Complex a))

Compose n => Compose (Cyclic n)

Defined in Data.Array.Knead.Shape.Orphan

Associated Types

type Composed (Cyclic n)

Methods

compose :: Cyclic n -> Exp (Composed (Cyclic n))

(Enum enum, Bounded enum) => Compose (Enumeration enum)

Defined in Data.Array.Knead.Shape.Orphan

Associated Types

type Composed (Enumeration enum)

Methods

compose :: Enumeration enum -> Exp (Composed (Enumeration enum))

Compose n => Compose (ZeroBased n)

Defined in Data.Array.Knead.Shape.Orphan

Associated Types

type Composed (ZeroBased n)

Methods

compose :: ZeroBased n -> Exp (Composed (ZeroBased n))

Compose (Exp a)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (Exp a)

Methods

compose :: Exp a -> Exp (Composed (Exp a))

Compose tuple => Compose (Tuple tuple)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (Tuple tuple)

Methods

compose :: Tuple tuple -> Exp (Composed (Tuple tuple))

(Compose sh, Composed sh ~ T (Tag (Composed sh)) (Rank (Composed sh)), Compose s, Composed s ~ Int) => Compose (sh :. s)

Defined in Data.Array.Knead.Shape.Cubic

Associated Types

type Composed (sh :. s)

Methods

compose :: (sh :. s) -> Exp (Composed (sh :. s))

(Compose a, Compose b) => Compose (a, b)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (a, b)

Methods

compose :: (a, b) -> Exp (Composed (a, b))

(Compose a, Compose b, Compose c) => Compose (a, b, c)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (a, b, c)

Methods

compose :: (a, b, c) -> Exp (Composed (a, b, c))

(Compose a, Compose b, Compose c, Compose d) => Compose (a, b, c, d)

Defined in LLVM.DSL.Expression

Associated Types

type Composed (a, b, c, d)

Methods

compose :: (a, b, c, d) -> Exp (Composed (a, b, c, d))

class Composed (Decomposed Exp pattern) ~ PatternTuple pattern => Decompose pattern where

Methods

decompose :: pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern

Analogous to decompose.

Instances

Decompose ()

Defined in LLVM.DSL.Expression

Methods

decompose :: () -> Exp (PatternTuple ()) -> Decomposed Exp ()

Decompose p => Decompose (Complex p)

Defined in LLVM.DSL.Expression

Methods

decompose :: Complex p -> Exp (PatternTuple (Complex p)) -> Decomposed Exp (Complex p)

Decompose pn => Decompose (Cyclic pn)

Defined in Data.Array.Knead.Shape.Orphan

Methods

decompose :: Cyclic pn -> Exp (PatternTuple (Cyclic pn)) -> Decomposed Exp (Cyclic pn)

Decompose (Enumeration enum)

Defined in Data.Array.Knead.Shape.Orphan

Methods

decompose :: Enumeration enum -> Exp (PatternTuple (Enumeration enum)) -> Decomposed Exp (Enumeration enum)

Decompose pn => Decompose (ZeroBased pn)

Defined in Data.Array.Knead.Shape.Orphan

Methods

decompose :: ZeroBased pn -> Exp (PatternTuple (ZeroBased pn)) -> Decomposed Exp (ZeroBased pn)

Decompose (Atom a)

Defined in LLVM.DSL.Expression

Methods

decompose :: Atom a -> Exp (PatternTuple (Atom a)) -> Decomposed Exp (Atom a)

Decompose p => Decompose (Tuple p)

Defined in LLVM.DSL.Expression

Methods

decompose :: Tuple p -> Exp (PatternTuple (Tuple p)) -> Decomposed Exp (Tuple p)

(Decompose sh, Decompose s, Decomposed Exp s ~ Exp Int, PatternTuple s ~ Int, PatternTuple sh ~ T (AtomTag sh) (AtomRank sh), Natural (AtomRank sh)) => Decompose (sh :. s)

Defined in Data.Array.Knead.Shape.Cubic

Methods

decompose :: (sh :. s) -> Exp (PatternTuple (sh :. s)) -> Decomposed Exp (sh :. s)

(Decompose pa, Decompose pb) => Decompose (pa, pb)

Defined in LLVM.DSL.Expression

Methods

decompose :: (pa, pb) -> Exp (PatternTuple (pa, pb)) -> Decomposed Exp (pa, pb)

(Decompose pa, Decompose pb, Decompose pc) => Decompose (pa, pb, pc)

Defined in LLVM.DSL.Expression

Methods

decompose :: (pa, pb, pc) -> Exp (PatternTuple (pa, pb, pc)) -> Decomposed Exp (pa, pb, pc)

(Decompose pa, Decompose pb, Decompose pc, Decompose pd) => Decompose (pa, pb, pc, pd)

Defined in LLVM.DSL.Expression

Methods

decompose :: (pa, pb, pc, pd) -> Exp (PatternTuple (pa, pb, pc, pd)) -> Decomposed Exp (pa, pb, pc, pd)

modify :: (Compose a, Decompose pattern) => pattern -> (Decomposed Exp pattern -> a) -> Exp (PatternTuple pattern) -> Exp (Composed a)

Analogus to modifyMultiValue.

modify2 :: (Compose a, Decompose patternA, Decompose patternB) => patternA -> patternB -> (Decomposed Exp patternA -> Decomposed Exp patternB -> a) -> Exp (PatternTuple patternA) -> Exp (PatternTuple patternB) -> Exp (Composed a)

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

You can construct complex numbers this way, but they will not make you happy, because the numeric operations require a RealFloat instance that we could only provide with lots of undefined methods (also in its superclasses). You may either define your own arithmetic or use the NumericPrelude type classes.

deconsComplex :: Exp (Complex a) -> (Exp a, Exp a)

cons :: C a => a -> Exp a

unit :: Exp ()

zero :: C a => Exp a

add :: Additive a => Exp a -> Exp a -> Exp a

sub :: Additive a => Exp a -> Exp a -> Exp a

mul :: PseudoRing a => Exp a -> Exp a -> Exp a

sqr :: PseudoRing a => Exp a -> Exp a

sqrt :: Algebraic a => Exp a -> Exp a

idiv :: Integral a => Exp a -> Exp a -> Exp a

irem :: Integral a => Exp a -> Exp a -> Exp a

shl :: BitShift a => Exp a -> Exp a -> Exp a

shr :: BitShift a => Exp a -> Exp a -> Exp a

fromInteger' :: IntegerConstant a => Integer -> Exp a

fromRational' :: RationalConstant a => Rational -> Exp a

boolPFrom8 :: Exp Bool8 -> Exp Bool

bool8FromP :: Exp Bool -> Exp Bool8

intFromBool8 :: NativeInteger i ir => Exp Bool8 -> Exp i

floatFromBool8 :: NativeFloating a ar => Exp Bool8 -> Exp a

fromFastMath :: Exp (Number flags a) -> Exp a

toFastMath :: Exp a -> Exp (Number flags a)

minBound :: Bounded a => Exp a

maxBound :: Bounded a => Exp a

cmp :: Comparison a => CmpPredicate -> Exp a -> Exp a -> Exp Bool

(==*) :: Comparison a => Exp a -> Exp a -> Exp Bool infix 4

(/=*) :: Comparison a => Exp a -> Exp a -> Exp Bool infix 4

(<*) :: Comparison a => Exp a -> Exp a -> Exp Bool infix 4

(>=*) :: Comparison a => Exp a -> Exp a -> Exp Bool infix 4

(>*) :: Comparison a => Exp a -> Exp a -> Exp Bool infix 4

(<=*) :: Comparison a => Exp a -> Exp a -> Exp Bool infix 4

min :: Real a => Exp a -> Exp a -> Exp a

max :: Real a => Exp a -> Exp a -> Exp a

true :: Exp Bool

false :: Exp Bool

(&&*) :: Exp Bool -> Exp Bool -> Exp Bool infixr 3

(||*) :: Exp Bool -> Exp Bool -> Exp Bool infixr 2

not :: Exp Bool -> Exp Bool

select :: Select a => Exp Bool -> Exp a -> Exp a -> Exp a

Like ifThenElse but computes both alternative expressions and then uses LLVM's efficient select instruction.

ifThenElse :: C a => Exp Bool -> Exp a -> Exp a -> Exp a

complement :: Logic a => Exp a -> Exp a

(.&.*) :: Logic a => Exp a -> Exp a -> Exp a infixl 7

(.|.*) :: Logic a => Exp a -> Exp a -> Exp a infixl 5

xor :: Logic a => Exp a -> Exp a -> Exp a infixl 6

toMaybe :: Exp Bool -> Exp a -> Exp (Maybe a)

maybe :: C b => Exp b -> (Exp a -> Exp b) -> Exp (Maybe a) -> Exp b