accelerate-utility 0.0 → 0.0.1

raw patch · 5 files changed

+332/−2 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• accelerate-utility.cabal +5/−2
• src/Data/Array/Accelerate/Utility/Lift/Exp.hs +11/−0
• src/Data/Array/Accelerate/Utility/Ord.hs +30/−0
• src/Data/Array/Accelerate/Utility/Sliced.hs +155/−0
• src/Data/Array/Accelerate/Utility/Sliced1.hs +131/−0

@@ -1,5 +1,5 @@ Name:             accelerate-utility-Version:          0.0+Version:          0.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+  Tag:         0.0.1   Type:        darcs   Location:    http://code.haskell.org/~thielema/accelerate-utility/ @@ -38,3 +38,6 @@     Data.Array.Accelerate.Utility.Lift.Run     Data.Array.Accelerate.Utility.Loop     Data.Array.Accelerate.Utility.Arrange+    Data.Array.Accelerate.Utility.Sliced+    Data.Array.Accelerate.Utility.Sliced1+    Data.Array.Accelerate.Utility.Ord

@@ -23,7 +23,9 @@    indexCons,    ) where +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 qualified Data.Tuple.HT as Tuple@@ -109,6 +111,15 @@    type Tuple (pa :. int) = Tuple pa :. Int    unlift (pa:.pb) ab =       (unlift pa $ A.indexTail ab) :. (unlift pb $ A.indexHead ab)+++instance (Unlift p) => Unlift (Complex p) where+   type Unlifted (Complex p) = Complex (Unlifted p)+   type Tuple (Complex p) = Complex (Tuple p)+   unlift (preal:+pimag) z =+      unlift preal (Complex.real z)+      :++      unlift pimag (Complex.imag z)   unliftPair :: (A.Elt a, A.Elt b) => Exp (a,b) -> (Exp a, Exp b)

@@ -0,0 +1,30 @@+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}+module Data.Array.Accelerate.Utility.Ord where++import qualified Data.Array.Accelerate as A+import Data.Array.Accelerate+          (Exp, Acc, Array, Elt, Slice, Shape, IsScalar, Scalar,+           (?), (<=*), )+++argmin ::+   (Elt a, Elt b, IsScalar a) =>+   Exp (a, b) -> Exp (a, b) -> Exp (a, b)+argmin x y  =  A.fst x <=* A.fst y ? (x,y)++argminimum ::+   (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>+   Acc (Array sh (a, b)) -> Acc (Scalar (a, b))+argminimum = A.fold1All argmin+++argmax ::+   (Elt a, Elt b, IsScalar a) =>+   Exp (a, b) -> Exp (a, b) -> Exp (a, b)+argmax x y  =  A.fst x <=* A.fst y ? (y,x)++argmaximum ::+   (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>+   Acc (Array sh (a, b)) -> Acc (A.Scalar (a, b))+argmaximum = A.fold1All argmax

@@ -0,0 +1,155 @@+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}+{- |+List-like functions on the inner dimension.+-}+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 qualified Data.Array.Accelerate as A+import Data.Array.Accelerate+          (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)),+           (!), (?), (==*), (<*), )+++length ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int) a) ->+   Exp Int+length = A.indexHead . A.shape++head ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int) a) ->+   Acc (Array sh a)+head xs = A.slice xs (A.constant $ A.Any:.(0::Int))++tail ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+tail xs =+   A.backpermute+      (Exp.modify (atom:.atom)+          (\(sh :. n) -> sh :. n-1)+          (A.shape xs))+      (Exp.modify (atom:.atom) $ \(ix:.k) -> ix :. k+1)+      xs++cons ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array sh a) ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+cons x xs =+   A.generate+      (Exp.modify (atom:.atom)+          (\(sh :. n) -> sh :. n+1)+          (A.shape xs))+      (Exp.modify (atom:.atom) $+       \(ix:.k) -> k ==* 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))++consExp ::+   (Shape sh, Slice sh, Elt a) =>+   Exp a ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+consExp x xs =+   A.generate+      (Exp.modify (atom:.atom)+          (\(z :. n) -> z :. n+1)+          (A.shape xs))+      (Exp.modify (atom:.atom) $+       \(ix:.k) -> k ==* 0 ? (x, xs ! A.lift (ix :. k-1)))+++append3 ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+append3 x y z =+   let (sh :. n) = Exp.unlift (atom :. atom) $ A.shape x+   in  A.reshape (A.lift $ sh :. 3*n) $ stack3 x y z++stack3 ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a)+stack3 x y z =+   A.generate+      (Exp.modify (atom :. atom)+         (\(sh :. n) -> sh :. (3::Int) :. n)+         (A.shape x))+      (Exp.modify (atom :. atom :. atom) $+       \(globalIx :. k :. j) ->+          let ix = A.lift $ globalIx :. j+          in  flip (A.caseof k) (x ! ix) $+                 ((==* 1), (y ! ix)) :+                 ((==* 2), (z ! ix)) :+                 [])+++take, drop ::+   (Shape sh, Slice sh, Elt a) =>+   Exp Int ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+take n arr =+   A.backpermute+      (Exp.modify (atom:.atom) (\(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)+      arr++pad ::+   (Shape sh, Slice sh, Elt a) =>+   Exp a -> Exp Int ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+pad x n arr =+   let sh:.m = Exp.unlift (atom:.atom) $ A.shape arr+   in  A.generate+          (A.lift $ sh:.n)+          (\ix -> A.indexHead ix <* m ? (arr!ix, x))+++{- |+@sliceVertical@ would be a simple 'A.reshape'.+-}+sliceHorizontal ::+   (Shape sh, Slice sh, Elt a) =>+   Exp DIM2 ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a)+sliceHorizontal nm arr =+   let _z:.n:.m = Exp.unlift (atom:.atom:.atom) nm+       sh = A.indexTail $ A.shape arr+   in  A.backpermute+          (A.lift $ sh :. n :. m)+          (Exp.modify (atom :. atom :. atom) $+           \(ix :. k :. j) -> ix :. n*j+k)+          arr++sieve ::+   (Shape sh, Slice sh, Elt a) =>+   Exp Int ->+   Exp Int ->+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int) a)+sieve m start arr =+   let sh:.n = Exp.unlift (atom:.atom) $ A.shape arr+   in  A.backpermute+          (A.lift $ sh :. div n m)+          (Exp.modify (atom :. atom) $+           \(ix :. j) -> ix :. m*j + start)+          arr

@@ -0,0 +1,131 @@+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}+{- |+List-like functions on the next-to-innermost dimension.+-}+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 qualified Data.Array.Accelerate as A+import Data.Array.Accelerate+          (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape,+           (!), (?), (<*), (==*), )+++length ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int:.Int) a) ->+   Exp Int+length = A.indexHead . A.indexTail . A.shape++head ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int) a)+head xs = A.slice xs (A.constant $ A.Any:.(0::Int):.A.All)++tail ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a)+tail xs =+   A.backpermute+      (Exp.modify (atom:.atom:.atom)+          (\(sh :. n :. m) -> sh :. n-1 :. m)+          (A.shape xs))+      (Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) -> ix :. k+1 :. j)+      xs++cons ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a)+cons x xs =+   A.generate+      (Exp.modify (atom:.atom:.atom)+          (\(sh :. n :. m) -> sh :. n+1 :. m)+          (A.shape xs))+      (Exp.modify (atom:.atom:.atom) $+       \(ix:.k:.j) ->+          k ==* 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j)))++{- |+The outer and innermost dimensions must match.+Otherwise you may or may not get out-of-bound errors.+-}+append ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int:.Int) a) ->+   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+   in  A.generate (A.lift $ shx :. nx+ny :. max lenx leny) $+       Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) ->+          k<*nx ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))++append3 ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a) ->+   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+   in  A.reshape (A.lift $ sh :. 3*n :. m) $ stack3 x y z++stack3 ::+   (Shape sh, Slice sh, Elt a) =>+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int:.Int) a)+stack3 x y z =+   A.generate+      (Exp.modify (atom :. atom :. atom)+         (\(sh :. n :. m) -> sh :. (3::Int) :. n :. m)+         (A.shape x))+      (Exp.modify (atom :. atom :. atom :. atom) $+       \(globalIx :. k :. j :. i) ->+          let ix = A.lift $ globalIx :. j :. i+          in  flip (A.caseof k) (x ! ix) $+                 ((==* 1), (y ! ix)) :+                 ((==* 2), (z ! ix)) :+                 [])+++take, drop ::+   (Shape sh, Slice sh, Elt a) =>+   Exp Int ->+   Acc (Array (sh:.Int:.Int) a) ->+   Acc (Array (sh:.Int:.Int) a)+take n arr =+   A.backpermute+      (Exp.modify (atom:.atom:.atom) (\(sh:._:.m) -> sh:.n:.m) $ A.shape arr)+      id arr++drop d arr =+   A.backpermute+      (Exp.modify (atom:.atom:.atom)+         (\(sh:.n:.m) -> sh :. n - d :. m) $ A.shape arr)+      (Exp.modify (atom:.atom:.atom) $+       \(ix:.k:.j) -> ix :. k + d :. j)+      arr++sieve ::+   (Shape sh, Slice sh, Elt a) =>+   Exp Int ->+   Exp Int ->+   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+   in  A.backpermute+          (A.lift $ sh :. div n fac :. m)+          (Exp.modify (atom :. atom :. atom) $+           \(ix :. k :. j) -> ix :. fac*k+start :. j)+          arr