packages feed

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 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)) :                  [])