accelerate-utility 0.0.1 → 0.1

raw patch · 6 files changed

+128/−77 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• accelerate-utility.cabal +2/−2
• src/Data/Array/Accelerate/Utility/Lift/Acc.hs +12/−5
• src/Data/Array/Accelerate/Utility/Lift/Exp.hs +68/−36
• src/Data/Array/Accelerate/Utility/Lift/Run.hs +12/−0
• src/Data/Array/Accelerate/Utility/Sliced.hs +18/−18
• src/Data/Array/Accelerate/Utility/Sliced1.hs +16/−16

@@ -1,5 +1,5 @@ Name:             accelerate-utility-Version:          0.0.1+Version:          0.1 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -15,7 +15,7 @@ Build-Type:       Simple  Source-Repository this-  Tag:         0.0.1+  Tag:         0.1   Type:        darcs   Location:    http://code.haskell.org/~thielema/accelerate-utility/ 

@@ -22,12 +22,24 @@    the,    ) where +import Data.Array.Accelerate.Utility.Lift.Exp (Exp(Exp), expr) import qualified Data.Array.Accelerate as A  import qualified Data.Tuple.HT as Tuple import Data.Tuple.HT (mapTriple)  +{- |+This class is like 'Data.Array.Accelerate.Utility.Lift.Exp.Unlift'+but for the 'Acc' environment.+It allows you to unlift an 'Acc' of nested tuples+into tuples of 'Exp' and 'Acc' values.+It can be quite handy when working with 'A.acond' and 'A.awhile'.+It can also be useful in connection with running an @accelerate@ algorithm+at a certain backend,+like 'Data.Array.Accelerate.Interpreter.run1'.+But in this case you might prefer "Data.Array.Accelerate.Utility.Lift.Run".+-} class (A.Arrays (Tuple pattern)) => Unlift pattern where    type Unlifted pattern    type Tuple pattern@@ -89,11 +101,6 @@    type Unlifted (Exp a) = A.Exp a    type Tuple (Exp a) = A.Scalar a    unlift _ = A.the--data Exp e = Exp--expr :: Exp e-expr = Exp   -- | like 'A.unit' in the 'Acc' environment

@@ -10,7 +10,7 @@    modify2,    modify3,    modify4,-   Atom(Atom), atom,+   Exp(Exp), expr, atom,    unliftPair,    unliftTriple,    unliftQuadruple,@@ -26,47 +26,74 @@ import qualified Data.Array.Accelerate.Data.Complex as Complex import qualified Data.Array.Accelerate as A import Data.Complex (Complex((:+)))-import Data.Array.Accelerate (Exp, (:.)((:.)))+import Data.Array.Accelerate ((:.)((:.)))  import qualified Data.Tuple.HT as Tuple import Data.Tuple.HT (mapTriple)  +{- |+This class simplifies untupling of expressions.+If you have a function++> g :: ((Exp a, Exp b), Exp (c,d)) -> (Exp e, Exp f)++you cannot apply it to an array @arr :: Array sh ((a,b),(c,d))@ using 'A.map'.+Here, the 'modify' function helps:++> modify ((expr,expr),expr) g :: Exp ((a,b),(c,d)) -> Exp (e,f)++The 'expr'-pattern tells, how deep the tuple shall be unlifted.+This way you can write:++> A.map+>    (Exp.modify ((expr,expr),expr) $ \((a,b), cd) -> g ((a,b), cd))+>    arr++'modify' is based on 'unlift'.+In contrast to 'A.unlift' it does not only unlift one level of tupels,+but is guided by an 'expr'-pattern.+In the example I have demonstrated,+how the pair @(a,b)@ is unlifted, but the pair @(c,d)@ is not.+For the result tuple, 'modify' simply calls 'A.lift'.+In contrast to 'A.unlift',+'A.lift' lifts over all tupel levels until it obtains a single 'Exp'.+-} class    (A.Elt (Tuple pattern), A.Plain (Unlifted pattern) ~ Tuple pattern) =>       Unlift pattern where    type Unlifted pattern    type Tuple pattern-   unlift :: pattern -> Exp (Tuple pattern) -> Unlifted pattern+   unlift :: pattern -> A.Exp (Tuple pattern) -> Unlifted pattern  modify ::-   (A.Lift Exp a, Unlift pattern) =>+   (A.Lift A.Exp a, Unlift pattern) =>    pattern ->    (Unlifted pattern -> a) ->-   Exp (Tuple pattern) -> Exp (A.Plain a)+   A.Exp (Tuple pattern) -> A.Exp (A.Plain a) modify p f = A.lift . f . unlift p  modify2 ::-   (A.Lift Exp a, Unlift patternA, Unlift patternB) =>+   (A.Lift A.Exp a, Unlift patternA, Unlift patternB) =>    patternA ->    patternB ->    (Unlifted patternA -> Unlifted patternB -> a) ->-   Exp (Tuple patternA) -> Exp (Tuple patternB) -> Exp (A.Plain a)+   A.Exp (Tuple patternA) -> A.Exp (Tuple patternB) -> A.Exp (A.Plain a) modify2 pa pb f a b = A.lift $ f (unlift pa a) (unlift pb b)  modify3 ::-   (A.Lift Exp a, Unlift patternA, Unlift patternB, Unlift patternC) =>+   (A.Lift A.Exp a, Unlift patternA, Unlift patternB, Unlift patternC) =>    patternA ->    patternB ->    patternC ->    (Unlifted patternA -> Unlifted patternB -> Unlifted patternC -> a) ->-   Exp (Tuple patternA) -> Exp (Tuple patternB) ->-   Exp (Tuple patternC) -> Exp (A.Plain a)+   A.Exp (Tuple patternA) -> A.Exp (Tuple patternB) ->+   A.Exp (Tuple patternC) -> A.Exp (A.Plain a) modify3 pa pb pc f a b c =    A.lift $ f (unlift pa a) (unlift pb b) (unlift pc c)  modify4 ::-   (A.Lift Exp a,+   (A.Lift A.Exp a,     Unlift patternA, Unlift patternB, Unlift patternC, Unlift patternD) =>    patternA ->    patternB ->@@ -74,23 +101,28 @@    patternD ->    (Unlifted patternA -> Unlifted patternB ->     Unlifted patternC -> Unlifted patternD -> a) ->-   Exp (Tuple patternA) -> Exp (Tuple patternB) ->-   Exp (Tuple patternC) -> Exp (Tuple patternD) -> Exp (A.Plain a)+   A.Exp (Tuple patternA) -> A.Exp (Tuple patternB) ->+   A.Exp (Tuple patternC) -> A.Exp (Tuple patternD) -> A.Exp (A.Plain a) modify4 pa pb pc pd f a b c d =    A.lift $ f (unlift pa a) (unlift pb b) (unlift pc c) (unlift pd d)  -instance (A.Elt a) => Unlift (Atom a) where-   type Unlifted (Atom a) = Exp a-   type Tuple (Atom a) = a+instance (A.Elt a) => Unlift (Exp a) where+   type Unlifted (Exp a) = A.Exp a+   type Tuple (Exp a) = a    unlift _ = id -data Atom a = Atom+data Exp e = Exp -atom :: Atom a-atom = Atom+expr :: Exp e+expr = Exp +{-# DEPRECATED atom "use expr instead" #-}+-- | for compatibility with accelerate-utility-0.0+atom :: Exp e+atom = expr + instance (Unlift pa, Unlift pb) => Unlift (pa,pb) where    type Unlifted (pa,pb) = (Unlifted pa, Unlifted pb)    type Tuple (pa,pb) = (Tuple pa, Tuple pb)@@ -106,8 +138,8 @@       mapTriple (unlift pa, unlift pb, unlift pc) . A.unlift  -instance (Unlift pa, A.Slice (Tuple pa), int ~ Atom Int) => Unlift (pa :. int) where-   type Unlifted (pa :. int) = Unlifted pa :. Exp Int+instance (Unlift pa, A.Slice (Tuple pa), int ~ Exp Int) => Unlift (pa :. int) where+   type Unlifted (pa :. int) = Unlifted pa :. A.Exp Int    type Tuple (pa :. int) = Tuple pa :. Int    unlift (pa:.pb) ab =       (unlift pa $ A.indexTail ab) :. (unlift pb $ A.indexHead ab)@@ -122,49 +154,49 @@       unlift pimag (Complex.imag z)  -unliftPair :: (A.Elt a, A.Elt b) => Exp (a,b) -> (Exp a, Exp b)+unliftPair :: (A.Elt a, A.Elt b) => A.Exp (a,b) -> (A.Exp a, A.Exp b) unliftPair = A.unlift  unliftTriple ::-   (A.Elt a, A.Elt b, A.Elt c) => Exp (a,b,c) -> (Exp a, Exp b, Exp c)+   (A.Elt a, A.Elt b, A.Elt c) => A.Exp (a,b,c) -> (A.Exp a, A.Exp b, A.Exp c) unliftTriple = A.unlift  unliftQuadruple ::    (A.Elt a, A.Elt b, A.Elt c, A.Elt d) =>-   Exp (a,b,c,d) -> (Exp a, Exp b, Exp c, Exp d)+   A.Exp (a,b,c,d) -> (A.Exp a, A.Exp b, A.Exp c, A.Exp d) unliftQuadruple = A.unlift -asExp :: Exp a -> Exp a+asExp :: A.Exp a -> A.Exp a asExp = id  mapFst ::    (A.Elt a, A.Elt b, A.Elt c) =>-   (Exp a -> Exp b) -> Exp (a,c) -> Exp (b,c)-mapFst f = modify (atom,atom) $ \(a,c) -> (f a, c)+   (A.Exp a -> A.Exp b) -> A.Exp (a,c) -> A.Exp (b,c)+mapFst f = modify (expr,expr) $ \(a,c) -> (f a, c)  mapSnd ::    (A.Elt a, A.Elt b, A.Elt c) =>-   (Exp b -> Exp c) -> Exp (a,b) -> Exp (a,c)-mapSnd f = modify (atom,atom) $ \(a,b) -> (a, f b)+   (A.Exp b -> A.Exp c) -> A.Exp (a,b) -> A.Exp (a,c)+mapSnd f = modify (expr,expr) $ \(a,b) -> (a, f b)   fst3 ::    (A.Elt a, A.Elt b, A.Elt c) =>-   Exp (a,b,c) -> Exp a-fst3 = modify (atom,atom,atom) Tuple.fst3+   A.Exp (a,b,c) -> A.Exp a+fst3 = modify (expr,expr,expr) Tuple.fst3  snd3 ::    (A.Elt a, A.Elt b, A.Elt c) =>-   Exp (a,b,c) -> Exp b-snd3 = modify (atom,atom,atom) Tuple.snd3+   A.Exp (a,b,c) -> A.Exp b+snd3 = modify (expr,expr,expr) Tuple.snd3  thd3 ::    (A.Elt a, A.Elt b, A.Elt c) =>-   Exp (a,b,c) -> Exp c-thd3 = modify (atom,atom,atom) Tuple.thd3+   A.Exp (a,b,c) -> A.Exp c+thd3 = modify (expr,expr,expr) Tuple.thd3    indexCons ::-   (A.Slice ix) => Exp ix -> Exp Int -> Exp (ix :. Int)+   (A.Slice ix) => A.Exp ix -> A.Exp Int -> A.Exp (ix :. Int) indexCons ix n = A.lift $ ix:.n

@@ -58,6 +58,18 @@   +{- |+If you have a function:++> f :: Exp a -> (Acc b, Acc c) -> (Acc d, Acc e)++you cannot run this immediately using 'Data.Array.Accelerate.Interpreter.run1',+since @run1@ expects a function+with a single 'Acc' parameter and a single 'Acc' result.+Using the 'with' function you can just run @f@ as is:++> with run1 f :: a -> (b,c) -> (d,e)+-} {- (Acc ((a,b),c)) -> Acc d) -> (((a,b),c) -> d) (Acc (a,b) -> Acc c -> Acc d) -> ((a,b) -> c -> d)

@@ -6,7 +6,7 @@ module Data.Array.Accelerate.Utility.Sliced where  import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp-import Data.Array.Accelerate.Utility.Lift.Exp (atom)+import Data.Array.Accelerate.Utility.Lift.Exp (expr)  import qualified Data.Array.Accelerate as A import Data.Array.Accelerate@@ -32,10 +32,10 @@    Acc (Array (sh:.Int) a) tail xs =    A.backpermute-      (Exp.modify (atom:.atom)+      (Exp.modify (expr:.expr)           (\(sh :. n) -> sh :. n-1)           (A.shape xs))-      (Exp.modify (atom:.atom) $ \(ix:.k) -> ix :. k+1)+      (Exp.modify (expr:.expr) $ \(ix:.k) -> ix :. k+1)       xs  cons ::@@ -45,10 +45,10 @@    Acc (Array (sh:.Int) a) cons x xs =    A.generate-      (Exp.modify (atom:.atom)+      (Exp.modify (expr:.expr)           (\(sh :. n) -> sh :. n+1)           (A.shape xs))-      (Exp.modify (atom:.atom) $+      (Exp.modify (expr:.expr) $        \(ix:.k) -> k ==* 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))  consExp ::@@ -58,10 +58,10 @@    Acc (Array (sh:.Int) a) consExp x xs =    A.generate-      (Exp.modify (atom:.atom)+      (Exp.modify (expr:.expr)           (\(z :. n) -> z :. n+1)           (A.shape xs))-      (Exp.modify (atom:.atom) $+      (Exp.modify (expr:.expr) $        \(ix:.k) -> k ==* 0 ? (x, xs ! A.lift (ix :. k-1)))  @@ -72,7 +72,7 @@    Acc (Array (sh:.Int) a) ->    Acc (Array (sh:.Int) a) append3 x y z =-   let (sh :. n) = Exp.unlift (atom :. atom) $ A.shape x+   let (sh :. n) = Exp.unlift (expr :. expr) $ A.shape x    in  A.reshape (A.lift $ sh :. 3*n) $ stack3 x y z  stack3 ::@@ -83,10 +83,10 @@    Acc (Array (sh:.Int:.Int) a) stack3 x y z =    A.generate-      (Exp.modify (atom :. atom)+      (Exp.modify (expr :. expr)          (\(sh :. n) -> sh :. (3::Int) :. n)          (A.shape x))-      (Exp.modify (atom :. atom :. atom) $+      (Exp.modify (expr :. expr :. expr) $        \(globalIx :. k :. j) ->           let ix = A.lift $ globalIx :. j           in  flip (A.caseof k) (x ! ix) $@@ -102,13 +102,13 @@    Acc (Array (sh:.Int) a) take n arr =    A.backpermute-      (Exp.modify (atom:.atom) (\(sh:._) -> sh:.n) $ A.shape arr)+      (Exp.modify (expr:.expr) (\(sh:._) -> sh:.n) $ A.shape arr)       id arr  drop d arr =    A.backpermute-      (Exp.modify (atom:.atom) (\(sh:.n) -> sh :. n - d) $ A.shape arr)-      (Exp.modify (atom:.atom) $ \(ix:.k) -> ix :. k + d)+      (Exp.modify (expr:.expr) (\(sh:.n) -> sh :. n - d) $ A.shape arr)+      (Exp.modify (expr:.expr) $ \(ix:.k) -> ix :. k + d)       arr  pad ::@@ -117,7 +117,7 @@    Acc (Array (sh:.Int) a) ->    Acc (Array (sh:.Int) a) pad x n arr =-   let sh:.m = Exp.unlift (atom:.atom) $ A.shape arr+   let sh:.m = Exp.unlift (expr:.expr) $ A.shape arr    in  A.generate           (A.lift $ sh:.n)           (\ix -> A.indexHead ix <* m ? (arr!ix, x))@@ -132,11 +132,11 @@    Acc (Array (sh:.Int) a) ->    Acc (Array (sh:.Int:.Int) a) sliceHorizontal nm arr =-   let _z:.n:.m = Exp.unlift (atom:.atom:.atom) nm+   let _z:.n:.m = Exp.unlift (expr:.expr:.expr) nm        sh = A.indexTail $ A.shape arr    in  A.backpermute           (A.lift $ sh :. n :. m)-          (Exp.modify (atom :. atom :. atom) $+          (Exp.modify (expr :. expr :. expr) $            \(ix :. k :. j) -> ix :. n*j+k)           arr @@ -147,9 +147,9 @@    Acc (Array (sh:.Int) a) ->    Acc (Array (sh:.Int) a) sieve m start arr =-   let sh:.n = Exp.unlift (atom:.atom) $ A.shape arr+   let sh:.n = Exp.unlift (expr:.expr) $ A.shape arr    in  A.backpermute           (A.lift $ sh :. div n m)-          (Exp.modify (atom :. atom) $+          (Exp.modify (expr :. expr) $            \(ix :. j) -> ix :. m*j + start)           arr

@@ -6,7 +6,7 @@ module Data.Array.Accelerate.Utility.Sliced1 where  import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp-import Data.Array.Accelerate.Utility.Lift.Exp (atom)+import Data.Array.Accelerate.Utility.Lift.Exp (expr)  import qualified Data.Array.Accelerate as A import Data.Array.Accelerate@@ -32,10 +32,10 @@    Acc (Array (sh:.Int:.Int) a) tail xs =    A.backpermute-      (Exp.modify (atom:.atom:.atom)+      (Exp.modify (expr:.expr:.expr)           (\(sh :. n :. m) -> sh :. n-1 :. m)           (A.shape xs))-      (Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) -> ix :. k+1 :. j)+      (Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) -> ix :. k+1 :. j)       xs  cons ::@@ -45,10 +45,10 @@    Acc (Array (sh:.Int:.Int) a) cons x xs =    A.generate-      (Exp.modify (atom:.atom:.atom)+      (Exp.modify (expr:.expr:.expr)           (\(sh :. n :. m) -> sh :. n+1 :. m)           (A.shape xs))-      (Exp.modify (atom:.atom:.atom) $+      (Exp.modify (expr:.expr:.expr) $        \(ix:.k:.j) ->           k ==* 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j))) @@ -62,10 +62,10 @@    Acc (Array (sh:.Int:.Int) a) ->    Acc (Array (sh:.Int:.Int) a) append x y =-   let ( shx:.nx:.lenx) = Exp.unlift (atom:.atom:.atom) $ A.shape x-       (_shy:.ny:.leny) = Exp.unlift (atom:.atom:.atom) $ A.shape y+   let ( shx:.nx:.lenx) = Exp.unlift (expr:.expr:.expr) $ A.shape x+       (_shy:.ny:.leny) = Exp.unlift (expr:.expr:.expr) $ A.shape y    in  A.generate (A.lift $ shx :. nx+ny :. max lenx leny) $-       Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) ->+       Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) ->           k<*nx ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))  append3 ::@@ -75,7 +75,7 @@    Acc (Array (sh:.Int:.Int) a) ->    Acc (Array (sh:.Int:.Int) a) append3 x y z =-   let (sh :. n :. m) = Exp.unlift (atom :. atom :. atom) $ A.shape x+   let (sh :. n :. m) = Exp.unlift (expr :. expr :. expr) $ A.shape x    in  A.reshape (A.lift $ sh :. 3*n :. m) $ stack3 x y z  stack3 ::@@ -86,10 +86,10 @@    Acc (Array (sh:.Int:.Int:.Int) a) stack3 x y z =    A.generate-      (Exp.modify (atom :. atom :. atom)+      (Exp.modify (expr :. expr :. expr)          (\(sh :. n :. m) -> sh :. (3::Int) :. n :. m)          (A.shape x))-      (Exp.modify (atom :. atom :. atom :. atom) $+      (Exp.modify (expr :. expr :. expr :. expr) $        \(globalIx :. k :. j :. i) ->           let ix = A.lift $ globalIx :. j :. i           in  flip (A.caseof k) (x ! ix) $@@ -105,14 +105,14 @@    Acc (Array (sh:.Int:.Int) a) take n arr =    A.backpermute-      (Exp.modify (atom:.atom:.atom) (\(sh:._:.m) -> sh:.n:.m) $ A.shape arr)+      (Exp.modify (expr:.expr:.expr) (\(sh:._:.m) -> sh:.n:.m) $ A.shape arr)       id arr  drop d arr =    A.backpermute-      (Exp.modify (atom:.atom:.atom)+      (Exp.modify (expr:.expr:.expr)          (\(sh:.n:.m) -> sh :. n - d :. m) $ A.shape arr)-      (Exp.modify (atom:.atom:.atom) $+      (Exp.modify (expr:.expr:.expr) $        \(ix:.k:.j) -> ix :. k + d :. j)       arr @@ -123,9 +123,9 @@    Acc (Array (sh:.Int:.Int) a) ->    Acc (Array (sh:.Int:.Int) a) sieve fac start arr =-   let sh:.n:.m = Exp.unlift (atom:.atom:.atom) $ A.shape arr+   let sh:.n:.m = Exp.unlift (expr:.expr:.expr) $ A.shape arr    in  A.backpermute           (A.lift $ sh :. div n fac :. m)-          (Exp.modify (atom :. atom :. atom) $+          (Exp.modify (expr :. expr :. expr) $            \(ix :. k :. j) -> ix :. fac*k+start :. j)           arr