packages feed

accelerate-utility 1.0.0.1 → 1.1

raw patch · 5 files changed

+40/−19 lines, 5 filesdep +non-emptydep ~acceleratePVP ok

version bump matches the API change (PVP)

Dependencies added: non-empty

Dependency ranges changed: accelerate

API changes (from Hackage documentation)

- 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.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: 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.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: type family Unpacked a;
- 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: instance Data.Array.Accelerate.Sugar.Array.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.Sugar.Elt.Elt a => Data.Array.Accelerate.Utility.Lift.Acc.Unlift (Data.Array.Accelerate.Utility.Lift.Exp.Exp a)
+ Data.Array.Accelerate.Utility.Lift.Acc: type Tuple pattern
+ Data.Array.Accelerate.Utility.Lift.Acc: type Unlifted pattern
+ Data.Array.Accelerate.Utility.Lift.Exp: accessElement :: Elt a => T [] (Exp a) -> Exp Int -> Exp a
+ Data.Array.Accelerate.Utility.Lift.Exp: instance (Data.Array.Accelerate.Utility.Lift.Exp.Unlift pa, Data.Array.Accelerate.Sugar.Shape.Slice (Data.Array.Accelerate.Utility.Lift.Exp.Tuple pa), int GHC.Types.~ Data.Array.Accelerate.Utility.Lift.Exp.Exp GHC.Types.Int) => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (pa Data.Array.Accelerate.Sugar.Shape.:. int)
+ Data.Array.Accelerate.Utility.Lift.Exp: instance Data.Array.Accelerate.Sugar.Elt.Elt a => Data.Array.Accelerate.Utility.Lift.Exp.Unlift (Data.Array.Accelerate.Utility.Lift.Exp.Exp a)
+ Data.Array.Accelerate.Utility.Lift.Exp: type Tuple pattern
+ Data.Array.Accelerate.Utility.Lift.Exp: type Unlifted pattern
+ Data.Array.Accelerate.Utility.Lift.Exp: unliftQuintuple :: (Elt a, Elt b, Elt c, Elt d, Elt e) => Exp (a, b, c, d, e) -> (Exp a, Exp b, Exp c, Exp d, Exp e)
+ Data.Array.Accelerate.Utility.Lift.Run: instance (Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc r, Data.Array.Accelerate.Sugar.Array.Arrays (Data.Array.Accelerate.Lift.Plain r), Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc s, Data.Array.Accelerate.Sugar.Array.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.Sugar.Array.Arrays (Data.Array.Accelerate.Lift.Plain r), Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc s, Data.Array.Accelerate.Sugar.Array.Arrays (Data.Array.Accelerate.Lift.Plain s), Data.Array.Accelerate.Lift.Lift Data.Array.Accelerate.Smart.Acc t, Data.Array.Accelerate.Sugar.Array.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.Sugar.Shape.Slice (Data.Array.Accelerate.Lift.Plain a), b GHC.Types.~ Data.Array.Accelerate.Smart.Exp GHC.Types.Int) => Data.Array.Accelerate.Utility.Lift.Run.Argument (a Data.Array.Accelerate.Sugar.Shape.:. b)
+ Data.Array.Accelerate.Utility.Lift.Run: instance Data.Array.Accelerate.Sugar.Array.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.Sugar.Elt.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.Sugar.Shape.Z
+ Data.Array.Accelerate.Utility.Lift.Run: type Arguments a f;
+ Data.Array.Accelerate.Utility.Lift.Run: type Packed a;
+ Data.Array.Accelerate.Utility.Lift.Run: type Plain f;
+ Data.Array.Accelerate.Utility.Lift.Run: type Result f;
+ Data.Array.Accelerate.Utility.Lift.Run: type Unpacked a;
+ Data.Array.Accelerate.Utility.Shape: instance (Data.Array.Accelerate.Utility.Shape.C sh, i GHC.Types.~ GHC.Types.Int) => Data.Array.Accelerate.Utility.Shape.C (sh Data.Array.Accelerate.Sugar.Shape.:. i)
+ Data.Array.Accelerate.Utility.Shape: instance Data.Array.Accelerate.Utility.Shape.C Data.Array.Accelerate.Sugar.Shape.Z
- Data.Array.Accelerate.Utility.Arrange: scatter :: (Shape ix, Shape ix', Elt ix', Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array ix ix') -> Acc (Array ix' a) -> Acc (Array ix a) -> Acc (Array ix' a)
+ Data.Array.Accelerate.Utility.Arrange: scatter :: (Shape ix, Shape ix', Elt ix', Elt a) => (Exp a -> Exp a -> Exp a) -> Acc (Array ix (Maybe ix')) -> Acc (Array ix' a) -> Acc (Array ix a) -> Acc (Array ix' a)
- Data.Array.Accelerate.Utility.Lift.Acc: class (Arrays (Tuple pattern)) => Unlift pattern where {
+ Data.Array.Accelerate.Utility.Lift.Acc: class (Arrays (Tuple pattern)) => Unlift pattern
- 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 {
+ Data.Array.Accelerate.Utility.Lift.Exp: class (Elt (Tuple pattern), Plain (Unlifted pattern) ~ Tuple pattern) => Unlift pattern
- 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: 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

Files

accelerate-utility.cabal view
@@ -1,10 +1,10 @@ Name:             accelerate-utility-Version:          1.0.0.1+Version:          1.1 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de> Maintainer:       Henning Thielemann <haskell@henning-thielemann.de>-Homepage:         http://hub.darcs.net/thielema/accelerate-utility/+Homepage:         https://hub.darcs.net/thielema/accelerate-utility/ Category:         Parallelism Synopsis:         Utility functions for the Accelerate framework Description:@@ -15,17 +15,18 @@ Build-Type:       Simple  Source-Repository this-  Tag:         1.0.0.1+  Tag:         1.1   Type:        darcs-  Location:    http://hub.darcs.net/thielema/accelerate-utility/+  Location:    https://hub.darcs.net/thielema/accelerate-utility/  Source-Repository head   Type:        darcs-  Location:    http://hub.darcs.net/thielema/accelerate-utility/+  Location:    https://hub.darcs.net/thielema/accelerate-utility/  Library   Build-Depends:-    accelerate >=1.0 && <1.2,+    accelerate >=1.3 && <1.5,+    non-empty >=0.3.3 && <0.4,     utility-ht >=0.0.8 && <0.1,     base >=4.5 && <5 
src/Data/Array/Accelerate/Utility/Arrange.hs view
@@ -25,7 +25,7 @@ scatter ::    (A.Shape ix, A.Shape ix', A.Elt ix', A.Elt a) =>    (Exp a -> Exp a -> Exp a) ->-   Acc (Array ix ix') -> Acc (Array ix' a) ->+   Acc (Array ix (Maybe ix')) -> Acc (Array ix' a) ->    Acc (Array ix a) -> Acc (Array ix' a) scatter f indices deflt xs =    A.permute f deflt (indices A.!) xs
src/Data/Array/Accelerate/Utility/Lift/Exp.hs view
@@ -1,6 +1,7 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE UndecidableInstances #-} module Data.Array.Accelerate.Utility.Lift.Exp (    Unlift,    Unlifted,@@ -14,6 +15,8 @@    unliftPair,    unliftTriple,    unliftQuadruple,+   unliftQuintuple,+   accessElement,    asExp,    mapFst,    mapSnd,@@ -28,6 +31,7 @@ import Data.Complex (Complex((:+))) import Data.Array.Accelerate ((:.)((:.))) +import qualified Data.NonEmpty as NonEmpty import qualified Data.Tuple.HT as Tuple import Data.Tuple.HT (mapTriple) @@ -165,6 +169,24 @@    (A.Elt a, A.Elt b, A.Elt c, A.Elt d) =>    A.Exp (a,b,c,d) -> (A.Exp a, A.Exp b, A.Exp c, A.Exp d) unliftQuadruple = A.unlift++unliftQuintuple ::+   (A.Elt a, A.Elt b, A.Elt c, A.Elt d, A.Elt e) =>+   A.Exp (a,b,c,d,e) -> (A.Exp a, A.Exp b, A.Exp c, A.Exp d, A.Exp e)+unliftQuintuple = A.unlift++{- |+Intended to access elements of a tuple.++> accessElement [x,y,z] k ==+>    A.ifThenElse (k A.== 1) y $+>    A.ifThenElse (k A.== 2) z $+>    x+-}+accessElement :: (A.Elt a) => NonEmpty.T [] (A.Exp a) -> A.Exp Int -> A.Exp a+accessElement (NonEmpty.Cons x xs) k =+   foldr (\(j,y) -> A.ifThenElse (k A.== fromInteger j) y) x (zip [1..] xs)+  asExp :: A.Exp a -> A.Exp a asExp = id
src/Data/Array/Accelerate/Utility/Sliced.hs view
@@ -6,13 +6,15 @@ module Data.Array.Accelerate.Utility.Sliced where  import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp-import Data.Array.Accelerate.Utility.Lift.Exp (expr)+import Data.Array.Accelerate.Utility.Lift.Exp (expr, accessElement)  import qualified Data.Array.Accelerate as A import Data.Array.Accelerate           (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)), (!), (?), ) +import Data.NonEmpty ((!:)) + length ::    (Shape sh, Slice sh, Elt a) =>    Acc (Array (sh:.Int) a) ->@@ -87,11 +89,8 @@          (A.shape x))       (Exp.modify (expr :. expr :. expr) $        \(globalIx :. k :. j) ->-          let ix = A.lift $ globalIx :. j-          in  flip (A.caseof k) (x ! ix) $-                 ((A.== 1), (y ! ix)) :-                 ((A.== 2), (z ! ix)) :-                 [])+         let ix = A.lift $ globalIx :. j+         in accessElement (x!ix !: y!ix : z!ix : []) k)   take, drop ::
src/Data/Array/Accelerate/Utility/Sliced1.hs view
@@ -6,13 +6,15 @@ module Data.Array.Accelerate.Utility.Sliced1 where  import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp-import Data.Array.Accelerate.Utility.Lift.Exp (expr)+import Data.Array.Accelerate.Utility.Lift.Exp (expr, accessElement)  import qualified Data.Array.Accelerate as A import Data.Array.Accelerate           (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape, (!), (?), ) +import Data.NonEmpty ((!:)) + length ::    (Shape sh, Slice sh, Elt a) =>    Acc (Array (sh:.Int:.Int) a) ->@@ -90,11 +92,8 @@          (A.shape x))       (Exp.modify (expr :. expr :. expr :. expr) $        \(globalIx :. k :. j :. i) ->-          let ix = A.lift $ globalIx :. j :. i-          in  flip (A.caseof k) (x ! ix) $-                 ((A.== 1), (y ! ix)) :-                 ((A.== 2), (z ! ix)) :-                 [])+         let ix = A.lift $ globalIx :. j :. i+         in accessElement (x!ix !: y!ix : z!ix : []) k)   take, drop ::