accelerate-utility 0.1.1 → 1.0
raw patch · 6 files changed
+28/−41 lines, 6 filesdep ~acceleratedep ~basePVP ok
version bump matches the API change (PVP)
Dependency ranges changed: accelerate, base
API changes (from Hackage documentation)
- Data.Array.Accelerate.Utility.Lift.Acc: instance (Unlift pa, Unlift pb) => Unlift (pa, pb)
- Data.Array.Accelerate.Utility.Lift.Acc: instance (Unlift pa, Unlift pb, Unlift pc) => Unlift (pa, pb, pc)
- Data.Array.Accelerate.Utility.Lift.Acc: instance Arrays a => Unlift (Acc a)
- Data.Array.Accelerate.Utility.Lift.Acc: instance Elt a => Unlift (Exp a)
- Data.Array.Accelerate.Utility.Lift.Exp: instance (Unlift pa, Slice (Tuple pa), int ~ Exp Int) => Unlift (pa :. int)
- Data.Array.Accelerate.Utility.Lift.Exp: instance (Unlift pa, Unlift pb) => Unlift (pa, pb)
- Data.Array.Accelerate.Utility.Lift.Exp: instance (Unlift pa, Unlift pb, Unlift pc) => Unlift (pa, pb, pc)
- Data.Array.Accelerate.Utility.Lift.Exp: instance Elt a => Unlift (Exp a)
- Data.Array.Accelerate.Utility.Lift.Exp: instance Unlift p => Unlift (Complex p)
- Data.Array.Accelerate.Utility.Lift.Run: instance (Argument a, Argument b) => Argument (a, b)
- Data.Array.Accelerate.Utility.Lift.Run: instance (Argument a, Argument b, Argument c) => Argument (a, b, c)
- Data.Array.Accelerate.Utility.Lift.Run: instance (Argument arg, C f) => C (arg -> f)
- Data.Array.Accelerate.Utility.Lift.Run: instance (Lift Acc r, Arrays (Plain r), Lift Acc s, Arrays (Plain s)) => C (r, s)
- Data.Array.Accelerate.Utility.Lift.Run: instance (Lift Acc r, Arrays (Plain r), Lift Acc s, Arrays (Plain s), Lift Acc t, Arrays (Plain t)) => C (r, s, t)
- Data.Array.Accelerate.Utility.Lift.Run: instance (Unlift Exp a, Lift Exp a, Slice (Plain a), b ~ Exp Int) => Argument (a :. b)
- Data.Array.Accelerate.Utility.Lift.Run: instance Argument Z
- Data.Array.Accelerate.Utility.Lift.Run: instance Arrays a => Argument (Acc a)
- Data.Array.Accelerate.Utility.Lift.Run: instance C (Acc r)
- Data.Array.Accelerate.Utility.Lift.Run: instance Elt a => Argument (Exp a)
- Data.Array.Accelerate.Utility.Shape: instance (C sh, i ~ Int) => C (sh :. i)
- Data.Array.Accelerate.Utility.Shape: instance C Z
+ Data.Array.Accelerate.Utility.Lift.Acc: instance (Data.Array.Accelerate.Utility.Lift.Acc.Unlift pa, Data.Array.Accelerate.Utility.Lift.Acc.Unlift pb) => Data.Array.Accelerate.Utility.Lift.Acc.Unlift (pa, pb)
+ Data.Array.Accelerate.Utility.Lift.Acc: instance (Data.Array.Accelerate.Utility.Lift.Acc.Unlift pa, Data.Array.Accelerate.Utility.Lift.Acc.Unlift pb, Data.Array.Accelerate.Utility.Lift.Acc.Unlift pc) => Data.Array.Accelerate.Utility.Lift.Acc.Unlift (pa, pb, pc)
+ Data.Array.Accelerate.Utility.Lift.Acc: instance Data.Array.Accelerate.Array.Sugar.Arrays a => Data.Array.Accelerate.Utility.Lift.Acc.Unlift (Data.Array.Accelerate.Utility.Lift.Acc.Acc a)
+ Data.Array.Accelerate.Utility.Lift.Acc: instance Data.Array.Accelerate.Array.Sugar.Elt a => Data.Array.Accelerate.Utility.Lift.Acc.Unlift (Data.Array.Accelerate.Utility.Lift.Exp.Exp a)
+ Data.Array.Accelerate.Utility.Lift.Acc: type family Tuple pattern;
+ Data.Array.Accelerate.Utility.Lift.Acc: }
+ Data.Array.Accelerate.Utility.Lift.Exp: instance (Data.Array.Accelerate.Utility.Lift.Exp.Unlift pa, Data.Array.Accelerate.Array.Sugar.Slice (Data.Array.Accelerate.Utility.Lift.Exp.Tuple pa), int ~ Data.Array.Accelerate.Utility.Lift.Exp.Exp GHC.Types.Int) => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (pa Data.Array.Accelerate.Array.Sugar.:. int)
+ Data.Array.Accelerate.Utility.Lift.Exp: instance (Data.Array.Accelerate.Utility.Lift.Exp.Unlift pa, Data.Array.Accelerate.Utility.Lift.Exp.Unlift pb) => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (pa, pb)
+ Data.Array.Accelerate.Utility.Lift.Exp: instance (Data.Array.Accelerate.Utility.Lift.Exp.Unlift pa, Data.Array.Accelerate.Utility.Lift.Exp.Unlift pb, Data.Array.Accelerate.Utility.Lift.Exp.Unlift pc) => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (pa, pb, pc)
+ Data.Array.Accelerate.Utility.Lift.Exp: instance Data.Array.Accelerate.Array.Sugar.Elt a => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (Data.Array.Accelerate.Utility.Lift.Exp.Exp a)
+ Data.Array.Accelerate.Utility.Lift.Exp: instance Data.Array.Accelerate.Utility.Lift.Exp.Unlift p => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (Data.Complex.Complex p)
+ Data.Array.Accelerate.Utility.Lift.Exp: type family Tuple pattern;
+ Data.Array.Accelerate.Utility.Lift.Exp: }
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc r, Data.Array.Accelerate.Array.Sugar.Arrays (Data.Array.Accelerate.Lift.Plain r), Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc s, Data.Array.Accelerate.Array.Sugar.Arrays (Data.Array.Accelerate.Lift.Plain s)) => Data.Array.Accelerate.Utility.Lift.Run.C (r, s)
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc r, Data.Array.Accelerate.Array.Sugar.Arrays (Data.Array.Accelerate.Lift.Plain r), Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc s, Data.Array.Accelerate.Array.Sugar.Arrays (Data.Array.Accelerate.Lift.Plain s), Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc t, Data.Array.Accelerate.Array.Sugar.Arrays (Data.Array.Accelerate.Lift.Plain t)) => Data.Array.Accelerate.Utility.Lift.Run.C (r, s, t)
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Lift.Unlift Data.Array.Accelerate.Smart.Exp a, Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Exp a, Data.Array.Accelerate.Array.Sugar.Slice (Data.Array.Accelerate.Lift.Plain a), b ~ Data.Array.Accelerate.Smart.Exp GHC.Types.Int) => Data.Array.Accelerate.Utility.Lift.Run.Argument (a Data.Array.Accelerate.Array.Sugar.:. b)
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Utility.Lift.Run.Argument a, Data.Array.Accelerate.Utility.Lift.Run.Argument b) => Data.Array.Accelerate.Utility.Lift.Run.Argument (a, b)
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Utility.Lift.Run.Argument a, Data.Array.Accelerate.Utility.Lift.Run.Argument b, Data.Array.Accelerate.Utility.Lift.Run.Argument c) => Data.Array.Accelerate.Utility.Lift.Run.Argument (a, b, c)
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Utility.Lift.Run.Argument arg, Data.Array.Accelerate.Utility.Lift.Run.C f) => Data.Array.Accelerate.Utility.Lift.Run.C (arg -> f)
+ Data.Array.Accelerate.Utility.Lift.Run: instance Data.Array.Accelerate.Array.Sugar.Arrays a => Data.Array.Accelerate.Utility.Lift.Run.Argument (Data.Array.Accelerate.Smart.Acc a)
+ Data.Array.Accelerate.Utility.Lift.Run: instance Data.Array.Accelerate.Array.Sugar.Elt a => Data.Array.Accelerate.Utility.Lift.Run.Argument (Data.Array.Accelerate.Smart.Exp a)
+ Data.Array.Accelerate.Utility.Lift.Run: instance Data.Array.Accelerate.Utility.Lift.Run.Argument Data.Array.Accelerate.Array.Sugar.Z
+ Data.Array.Accelerate.Utility.Lift.Run: instance Data.Array.Accelerate.Utility.Lift.Run.C (Data.Array.Accelerate.Smart.Acc r)
+ Data.Array.Accelerate.Utility.Lift.Run: type family Unpacked a;
+ Data.Array.Accelerate.Utility.Lift.Run: }
+ Data.Array.Accelerate.Utility.Shape: instance (Data.Array.Accelerate.Utility.Shape.C sh, i ~ GHC.Types.Int) => Data.Array.Accelerate.Utility.Shape.C (sh Data.Array.Accelerate.Array.Sugar.:. i)
+ Data.Array.Accelerate.Utility.Shape: instance Data.Array.Accelerate.Utility.Shape.C Data.Array.Accelerate.Array.Sugar.Z
- Data.Array.Accelerate.Utility.Lift.Acc: class Arrays (Tuple pattern) => Unlift pattern where type family Unlifted pattern type family Tuple pattern
+ Data.Array.Accelerate.Utility.Lift.Acc: class (Arrays (Tuple pattern)) => Unlift pattern where type Unlifted pattern type Tuple pattern where {
- Data.Array.Accelerate.Utility.Lift.Acc: singleton :: Elt e => e -> Scalar e
+ Data.Array.Accelerate.Utility.Lift.Acc: singleton :: (Elt e) => e -> Scalar e
- Data.Array.Accelerate.Utility.Lift.Acc: the :: Elt e => Scalar e -> e
+ Data.Array.Accelerate.Utility.Lift.Acc: the :: (Elt e) => Scalar e -> e
- Data.Array.Accelerate.Utility.Lift.Exp: class (Elt (Tuple pattern), Plain (Unlifted pattern) ~ Tuple pattern) => Unlift pattern where type family Unlifted pattern type family Tuple pattern
+ Data.Array.Accelerate.Utility.Lift.Exp: class (Elt (Tuple pattern), Plain (Unlifted pattern) ~ Tuple pattern) => Unlift pattern where type Unlifted pattern type Tuple pattern where {
- Data.Array.Accelerate.Utility.Lift.Exp: indexCons :: Slice ix => Exp ix -> Exp Int -> Exp (ix :. Int)
+ Data.Array.Accelerate.Utility.Lift.Exp: indexCons :: (Slice ix) => Exp ix -> Exp Int -> Exp (ix :. Int)
- Data.Array.Accelerate.Utility.Lift.Run: class Arrays (Packed a) => Argument a where type family Packed a type family Unpacked a
+ Data.Array.Accelerate.Utility.Lift.Run: class (Arrays (Packed a)) => Argument a where type Packed a type Unpacked a where {
- Data.Array.Accelerate.Utility.Lift.Run: class C f where type family Arguments a f type family Result f type family Plain f
+ Data.Array.Accelerate.Utility.Lift.Run: class C f where type Arguments a f type Result f type Plain f where {
- Data.Array.Accelerate.Utility.Lift.Run: with :: C f => ((Acc (Arguments () f) -> Acc (Result f)) -> ((Arguments () f) -> Result f)) -> f -> Plain f
+ Data.Array.Accelerate.Utility.Lift.Run: with :: (C f) => ((Acc (Arguments () f) -> Acc (Result f)) -> (Arguments () f -> Result f)) -> f -> Plain f
- Data.Array.Accelerate.Utility.Lift.Run: with1 :: (C f, Arrays a) => ((Acc (Arguments a f) -> Acc (Result f)) -> ((Arguments a f) -> Result f)) -> (Acc a -> f) -> a -> Plain f
+ Data.Array.Accelerate.Utility.Lift.Run: with1 :: (C f, Arrays a) => ((Acc (Arguments a f) -> Acc (Result f)) -> (Arguments a f -> Result f)) -> (Acc a -> f) -> a -> Plain f
- Data.Array.Accelerate.Utility.Loop: nest :: Arrays a => Exp Int -> (Acc a -> Acc a) -> Acc a -> Acc a
+ Data.Array.Accelerate.Utility.Loop: nest :: (Arrays a) => Exp Int -> (Acc a -> Acc a) -> Acc a -> Acc a
- Data.Array.Accelerate.Utility.Loop: nestLog2 :: Arrays a => Exp Int -> (Acc a -> Acc a) -> Acc a -> Acc a
+ Data.Array.Accelerate.Utility.Loop: nestLog2 :: (Arrays a) => Exp Int -> (Acc a -> Acc a) -> Acc a -> Acc a
- Data.Array.Accelerate.Utility.Ord: argmax :: (Elt a, Elt b, IsScalar a) => Exp (a, b) -> Exp (a, b) -> Exp (a, b)
+ Data.Array.Accelerate.Utility.Ord: argmax :: (Elt a, Elt b, Ord a) => Exp (a, b) -> Exp (a, b) -> Exp (a, b)
- Data.Array.Accelerate.Utility.Ord: argmaximum :: (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) => Acc (Array sh (a, b)) -> Acc (Scalar (a, b))
+ Data.Array.Accelerate.Utility.Ord: argmaximum :: (Slice sh, Shape sh, Elt a, Elt b, Ord a) => Acc (Array sh (a, b)) -> Acc (Scalar (a, b))
- Data.Array.Accelerate.Utility.Ord: argmin :: (Elt a, Elt b, IsScalar a) => Exp (a, b) -> Exp (a, b) -> Exp (a, b)
+ Data.Array.Accelerate.Utility.Ord: argmin :: (Elt a, Elt b, Ord a) => Exp (a, b) -> Exp (a, b) -> Exp (a, b)
- Data.Array.Accelerate.Utility.Ord: argminimum :: (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) => Acc (Array sh (a, b)) -> Acc (Scalar (a, b))
+ Data.Array.Accelerate.Utility.Ord: argminimum :: (Slice sh, Shape sh, Elt a, Elt b, Ord a) => Acc (Array sh (a, b)) -> Acc (Scalar (a, b))
Files
- accelerate-utility.cabal +4/−4
- src/Data/Array/Accelerate/Utility/Lift/Run.hs +2/−2
- src/Data/Array/Accelerate/Utility/Loop.hs +4/−14
- src/Data/Array/Accelerate/Utility/Ord.hs +7/−8
- src/Data/Array/Accelerate/Utility/Sliced.hs +6/−7
- src/Data/Array/Accelerate/Utility/Sliced1.hs +5/−6
accelerate-utility.cabal view
@@ -1,5 +1,5 @@ Name: accelerate-utility-Version: 0.1.1+Version: 1.0 License: BSD3 License-File: LICENSE Author: Henning Thielemann <haskell@henning-thielemann.de>@@ -15,7 +15,7 @@ Build-Type: Simple Source-Repository this- Tag: 0.1.1+ Tag: 1.0 Type: darcs Location: http://hub.darcs.net/thielema/accelerate-utility/ @@ -25,9 +25,9 @@ Library Build-Depends:- accelerate >=0.15 && <0.16,+ accelerate >=1.0 && <1.2, utility-ht >=0.0.8 && <0.1,- base >=4.5 && <4.10+ base >=4.5 && <4.11 GHC-Options: -Wall -fwarn-missing-import-lists Hs-Source-Dirs: src
src/Data/Array/Accelerate/Utility/Lift/Run.hs view
@@ -82,13 +82,13 @@ with1 :: (A.Arrays a) => ((Acc (Arguments a f) -> Acc (Result f)) ->- ((Arguments a f) -> Result f)) ->+ (Arguments a f -> Result f)) -> (Acc a -> f) -> a -> Plain f with :: (C f) => ((Acc (Arguments () f) -> Acc (Result f)) ->- ((Arguments () f) -> Result f)) ->+ (Arguments () f -> Result f)) -> f -> Plain f with run f = with1 run (const f) ()
src/Data/Array/Accelerate/Utility/Loop.hs view
@@ -14,34 +14,24 @@ nest n0 f x0 = A.asnd $ A.awhile- (A.map (A.>* 0) . A.afst)+ (A.map (A.> 0) . A.afst) (A.lift . (\(n, x) -> (A.map (subtract 1) n, f x)) . A.unlift) (A.lift (A.unit n0, x0)) _nest n0 f x0 = A.asnd $ A.awhile- (A.unit . (A.>* 0) . A.the . A.afst)+ (A.unit . (A.> 0) . A.the . A.afst) (A.lift . (\(n, x) -> (A.unit $ A.the n - 1, f x)) . A.unlift) (A.lift (A.unit n0, x0)) -nestLog2, _nestLog2 ::+nestLog2 :: (A.Arrays a) => Exp Int -> (Acc a -> Acc a) -> Acc a -> Acc a nestLog2 n0 f x0 = A.asnd $ A.awhile- (A.map (A.>* 1) . A.afst)+ (A.map (A.> 1) . A.afst) (A.lift . (\(n, x) -> (A.map (flip div 2 . (1+)) n, f x)) . A.unlift) (A.lift (A.unit n0, x0))--{--This is an infinite loop,-because A.acond always has to generate code for both branches.--}-_nestLog2 n0 f x0 =- let go n x =- A.acond (n A.<=* 1) x $- go (div (n+1) 2) (f x)- in go n0 x0
src/Data/Array/Accelerate/Utility/Ord.hs view
@@ -4,27 +4,26 @@ import qualified Data.Array.Accelerate as A import Data.Array.Accelerate- (Exp, Acc, Array, Elt, Slice, Shape, IsScalar, Scalar,- (?), (<=*), )+ (Exp, Acc, Array, Elt, Slice, Shape, Scalar, (?), ) argmin ::- (Elt a, Elt b, IsScalar a) =>+ (Elt a, Elt b, A.Ord a) => Exp (a, b) -> Exp (a, b) -> Exp (a, b)-argmin x y = A.fst x <=* A.fst y ? (x,y)+argmin x y = A.fst x A.<= A.fst y ? (x,y) argminimum ::- (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>+ (Slice sh, Shape sh, Elt a, Elt b, A.Ord a) => Acc (Array sh (a, b)) -> Acc (Scalar (a, b)) argminimum = A.fold1All argmin argmax ::- (Elt a, Elt b, IsScalar a) =>+ (Elt a, Elt b, A.Ord a) => Exp (a, b) -> Exp (a, b) -> Exp (a, b)-argmax x y = A.fst x <=* A.fst y ? (y,x)+argmax x y = A.fst x A.<= A.fst y ? (y,x) argmaximum ::- (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>+ (Slice sh, Shape sh, Elt a, Elt b, A.Ord a) => Acc (Array sh (a, b)) -> Acc (A.Scalar (a, b)) argmaximum = A.fold1All argmax
src/Data/Array/Accelerate/Utility/Sliced.hs view
@@ -10,8 +10,7 @@ import qualified Data.Array.Accelerate as A import Data.Array.Accelerate- (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)),- (!), (?), (>*), (==*), )+ (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)), (!), (?), ) length ::@@ -49,7 +48,7 @@ (\(sh :. n) -> sh :. n+1) (A.shape xs)) (Exp.modify (expr:.expr) $- \(ix:.k) -> k ==* 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))+ \(ix:.k) -> k A.== 0 ? (x ! ix, xs ! A.lift (ix :. k-1))) consExp :: (Shape sh, Slice sh, Elt a) =>@@ -62,7 +61,7 @@ (\(z :. n) -> z :. n+1) (A.shape xs)) (Exp.modify (expr:.expr) $- \(ix:.k) -> k ==* 0 ? (x, xs ! A.lift (ix :. k-1)))+ \(ix:.k) -> k A.== 0 ? (x, xs ! A.lift (ix :. k-1))) append3 ::@@ -90,8 +89,8 @@ \(globalIx :. k :. j) -> let ix = A.lift $ globalIx :. j in flip (A.caseof k) (x ! ix) $- ((==* 1), (y ! ix)) :- ((==* 2), (z ! ix)) :+ ((A.== 1), (y ! ix)) :+ ((A.== 2), (z ! ix)) : []) @@ -120,7 +119,7 @@ let sh:.m = Exp.unlift (expr:.expr) $ A.shape arr in A.generate (A.lift $ sh:.n)- (\ix -> m >* A.indexHead ix ? (arr!ix, x))+ (\ix -> m A.> A.indexHead ix ? (arr!ix, x)) {- |
src/Data/Array/Accelerate/Utility/Sliced1.hs view
@@ -10,8 +10,7 @@ import qualified Data.Array.Accelerate as A import Data.Array.Accelerate- (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape,- (!), (?), (>*), (==*), )+ (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape, (!), (?), ) length ::@@ -50,7 +49,7 @@ (A.shape xs)) (Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) ->- k ==* 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j)))+ k A.== 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j))) {- | The outer and innermost dimensions must match.@@ -66,7 +65,7 @@ (_shy:.ny:.leny) = Exp.unlift (expr:.expr:.expr) $ A.shape y in A.generate (A.lift $ shx :. nx+ny :. max lenx leny) $ Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) ->- nx >* k ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))+ nx A.> k ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j)) append3 :: (Shape sh, Slice sh, Elt a) =>@@ -93,8 +92,8 @@ \(globalIx :. k :. j :. i) -> let ix = A.lift $ globalIx :. j :. i in flip (A.caseof k) (x ! ix) $- ((==* 1), (y ! ix)) :- ((==* 2), (z ! ix)) :+ ((A.== 1), (y ! ix)) :+ ((A.== 2), (z ! ix)) : [])