Data.Array.Knead.Expression

Documentation

newtype Exp a

Constructors

Exp

Fields

unExp :: forall r. CodeGenFunction r (T a)

Instances

Value Exp

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

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

Compose (Exp a)

class Value val where

Methods

lift0 :: T a -> val a

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

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

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

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

Instances

Value T

Value Exp

liftM :: (forall r. T a -> CodeGenFunction r (T b)) -> Exp a -> Exp b

liftM2 :: (forall r. T a -> T b -> CodeGenFunction r (T c)) -> Exp a -> Exp b -> Exp c

liftM3 :: (forall r. T a -> T b -> T c -> CodeGenFunction r (T d)) -> Exp a -> Exp b -> Exp c -> Exp d

unliftM1 :: (Exp a -> Exp b) -> T a -> CodeGenFunction r (T b)

unliftM2 :: (Exp a -> Exp b -> Exp c) -> T a -> T b -> CodeGenFunction r (T c)

unliftM3 :: (Exp a -> Exp b -> Exp c -> Exp d) -> T a -> T b -> T c -> CodeGenFunction r (T d)

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

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

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)

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

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 (Exp a)

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

(Compose sh, ~ * (Composed sh) (T (Tag (Composed sh)) (Unwrap (Composed sh))), Compose s) => Compose (:. sh s)

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

(Compose a, Compose b, Compose c, Compose d) => Compose (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 (Atom a)

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

Decompose tag sh => Decompose (T tag sh)

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

(Decompose pa, Decompose pb, Decompose pc, Decompose pd) => Decompose (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)

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

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

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