Safe Haskell | None |
---|

Generate and apply index maps.
This unifies the `replicate`

and `slice`

functions of the `accelerate`

package.
However the structure of slicing and replicating cannot depend on parameters.
If you need that, you must use `backpermute`

and friends.

- data T sh0 sh1
- type Cubic rank0 rank1 = T (Shape rank0) (Shape rank1)
- apply :: (C array, C sh0, C sh1, C a) => T sh0 sh1 -> array sh0 a -> array sh1 a
- passAny :: Cubic rank rank
- pass :: (Natural rank0, Natural rank1) => Cubic rank0 rank1 -> Cubic (Succ rank0) (Succ rank1)
- pick :: (Natural rank0, Natural rank1) => Exp Int -> Cubic rank0 rank1 -> Cubic (Succ rank0) rank1
- pickFst :: Exp (Index n) -> T (n, sh) sh
- pickSnd :: Exp (Index n) -> T (sh, n) sh
- extrude :: (Natural rank0, Natural rank1) => Exp Int -> Cubic rank0 rank1 -> Cubic rank0 (Succ rank1)
- extrudeFst :: Exp n -> T sh (n, sh)
- extrudeSnd :: Exp n -> T sh (sh, n)
- transpose :: T (sh0, sh1) (sh1, sh0)
- ($:.) :: (Process proc0, Process proc1) => proc0 -> (proc0 -> proc1) -> proc1
- id :: T sh sh
- first :: T sh0 sh1 -> T (sh0, sh) (sh1, sh)
- second :: T sh0 sh1 -> T (sh, sh0) (sh, sh1)
- compose :: T sh0 sh1 -> T sh1 sh2 -> T sh0 sh2

# Documentation

apply :: (C array, C sh0, C sh1, C a) => T sh0 sh1 -> array sh0 a -> array sh1 aSource

This is essentially a `backpermute`

.

pass :: (Natural rank0, Natural rank1) => Cubic rank0 rank1 -> Cubic (Succ rank0) (Succ rank1)Source

Like `All`

in `accelerate`

.

pick :: (Natural rank0, Natural rank1) => Exp Int -> Cubic rank0 rank1 -> Cubic (Succ rank0) rank1Source

Like `Int`

in `accelerate/slice`

.

extrude :: (Natural rank0, Natural rank1) => Exp Int -> Cubic rank0 rank1 -> Cubic rank0 (Succ rank1)Source

Like `Int`

in `accelerate/replicate`

.

extrudeFst :: Exp n -> T sh (n, sh)Source

Extrusion has the potential to do duplicate work.
Only use it to add dimensions of size 1, e.g. numeric 1 or unit `()`

or to duplicate slices of physical arrays.

extrudeSnd :: Exp n -> T sh (sh, n)Source

($:.) :: (Process proc0, Process proc1) => proc0 -> (proc0 -> proc1) -> proc1Source

Use this for combining several dimension manipulators. E.g.

apply (passAny $:. pick 3 $:. pass $:. replicate 10) array

The constraint `(Process proc0, Process proc1)`

is a bit weak.
We like to enforce that the type constructor like `Slice.T`

is the same in `proc0`

and `proc1`

, and only the parameters differ.
Currently this coherence is achieved,
because we only provide functions of type `proc0 -> proc1`

with this condition.