knead-0.5: Repa-like array processing using LLVM JIT

Safe HaskellNone

Data.Array.Knead.Parameterized.Symbolic

Documentation

data Array p sh a Source

Instances

C (Array p) 

data Exp a

Instances

Value Exp 
(Transcendental a, Real a, RationalConstant a) => Floating (Exp a) 
(Field a, Real a, RationalConstant a) => Fractional (Exp a) 
(PseudoRing a, Real a, IntegerConstant a) => Num (Exp a) 
Compose (Exp a) 
(Transcendental a, RationalConstant a) => C (Exp a) 
(Transcendental a, RationalConstant a) => C (Exp a) 
(Field a, RationalConstant a) => C (Exp a) 
(Real a, PseudoRing a, IntegerConstant a) => C (Exp a) 
(PseudoRing a, IntegerConstant a) => C (Exp a) 
Additive a => C (Exp a)

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

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

extendParameter :: (q -> p) -> Array p sh a -> Array q sh aSource

withExp :: MV x => (Exp x -> Array shb b -> Array sha a) -> T p x -> Array p shb b -> Array p sha aSource

withExp2 :: MV x => (Exp x -> Array sha a -> Array shb b -> Array shc c) -> T p x -> Array p sha a -> Array p shb b -> Array p shc cSource

withExp3 :: MV x => (Exp x -> Array sha a -> Array shb b -> Array shc c -> Array shd d) -> T p x -> Array p sha a -> Array p shb b -> Array p shc c -> Array p shd dSource

(!) :: (C sh, Index sh ~ ix, MV ix, Scalar z) => Array p sh a -> T p ix -> Array p z aSource

fill :: (C sh, MV sh, MV a) => T p sh -> T p a -> Array p sh aSource

gather :: (C sh0, Index sh0 ~ ix0, C sh1, C a) => Array p sh1 ix0 -> Array p sh0 a -> Array p sh1 aSource

backpermute :: (C sh0, Index sh0 ~ ix0, C sh1, Index sh1 ~ ix1, MV sh1, C a) => T p sh1 -> (Exp ix1 -> Exp ix0) -> Array p sh0 a -> Array p sh1 aSource

id :: (C sh, MV sh, Index sh ~ ix) => T p sh -> Array p sh ixSource

map :: (C sh, MV c) => (Exp c -> Exp a -> Exp b) -> T p c -> Array p sh a -> Array p sh bSource

zipWith :: (C sh, MV d) => (Exp d -> Exp a -> Exp b -> Exp c) -> T p d -> Array p sh a -> Array p sh b -> Array p sh cSource

fold1 :: (C sh0, C sh1, MV c, C a) => (Exp c -> Exp a -> Exp a -> Exp a) -> T p c -> Array p (sh0, sh1) a -> Array p sh0 aSource

fold1All :: (C sh, Scalar z, MV c, C a) => (Exp c -> Exp a -> Exp a -> Exp a) -> T p c -> Array p sh a -> Array p z aSource