Adapted to simplified VECTORISE pragmas
authorManuel M T Chakravarty <chak@cse.unsw.edu.au>
Sun, 9 Dec 2012 08:25:29 +0000 (19:25 +1100)
committerManuel M T Chakravarty <chak@cse.unsw.edu.au>
Tue, 5 Feb 2013 09:15:32 +0000 (20:15 +1100)
12 files changed:
dph-lifted-copy/Data/Array/Parallel/Prelude/Base.hs
dph-lifted-copy/Data/Array/Parallel/Prelude/Bool.hs
dph-lifted-copy/Data/Array/Parallel/Prelude/Double.hs
dph-lifted-copy/Data/Array/Parallel/Prelude/Float.hs
dph-lifted-copy/Data/Array/Parallel/Prelude/Int.hs
dph-lifted-copy/Data/Array/Parallel/Prelude/Word8.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Base.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Bool.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Double.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Int.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Ordering.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Word8.hs

index 1eb704c..a736216 100644 (file)
@@ -6,8 +6,6 @@ module Data.Array.Parallel.Prelude.Base
   ( PArr
   -- , ()
   , Bool
   ( PArr
   -- , ()
   , Bool
-  , Word8, Int
-  , Float, Double
   )
 where
 
   )
 where
 
@@ -16,16 +14,10 @@ import Data.Array.Parallel.Prim ()       -- dependency required by the vectorise
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.Lifted.Closure
 
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.Lifted.Closure
 
-import Data.Word (Word8)
+{-# VECTORISE type PArr = PArray #-}
+{-# VECTORISE type PArray = PArray #-}
 
 
-
-{-# VECTORISE SCALAR type PArr = PArray #-}
-{-# VECTORISE SCALAR type PArray = PArray #-}
 {-# VECTORISE SCALAR type (->) = (:->) #-}
 
 {-# VECTORISE SCALAR type (->) = (:->) #-}
 
-{-# VECTORISE type () = () #-}
-{-# VECTORISE type Bool = Bool #-}
-{-# VECTORISE SCALAR type Word8 #-}
-{-# VECTORISE SCALAR type Int #-}
-{-# VECTORISE SCALAR type Float #-}
-{-# VECTORISE SCALAR type Double #-}
+{-# VECTORISE SCALAR type () #-}
+{-# VECTORISE SCALAR type Bool #-}
index f49cf9a..db38e27 100644 (file)
@@ -87,9 +87,7 @@ orP_v = closure1 (scalar_fold (||) False) (scalar_folds (||) False)
 fromBool :: Bool -> Int
 fromBool False = 0
 fromBool True  = 1
 fromBool :: Bool -> Int
 fromBool False = 0
 fromBool True  = 1
-{-# VECTORISE SCALAR fromBool #-}
 
 toBool :: Int -> Bool
 toBool 0 = False
 toBool _ = True
 
 toBool :: Int -> Bool
 toBool 0 = False
 toBool _ = True
-{-# VECTORISE SCALAR toBool #-}
index b0c1a4c..7dec054 100644 (file)
@@ -36,6 +36,7 @@ import Data.Array.Parallel.Lifted.Scalar
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
+import Prelude (Int, Double)
 
 
 infixr 8 **
 
 
 infixr 8 **
@@ -46,23 +47,15 @@ infix 4 ==, /=, <, <=, >, >=
 
 (==), (/=), (<), (<=), (>), (>=) :: Double -> Double -> Bool
 (==) = (P.==)
 
 (==), (/=), (<), (<=), (>), (>=) :: Double -> Double -> Bool
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
 
 min, max :: Double -> Double -> Double
 min = P.min
 
 min, max :: Double -> Double -> Double
 min = P.min
-{-# VECTORISE SCALAR min #-}
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
 
 minimumP, maximumP :: PArr Double -> Double
 {-# NOINLINE minimumP #-}
 
 minimumP, maximumP :: PArr Double -> Double
 {-# NOINLINE minimumP #-}
@@ -110,17 +103,12 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 (+), (-), (*) :: Double -> Double -> Double
 (+) = (P.+)
 
 (+), (-), (*) :: Double -> Double -> Double
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
 
 negate, abs :: Double -> Double
 negate = P.negate
 
 negate, abs :: Double -> Double
 negate = P.negate
-{-# VECTORISE SCALAR negate #-}
 abs = P.abs
 abs = P.abs
-{-# VECTORISE SCALAR abs #-}
 
 sumP, productP :: PArr Double -> Double
 {-# NOINLINE sumP #-}
 
 sumP, productP :: PArr Double -> Double
 {-# NOINLINE sumP #-}
@@ -140,11 +128,9 @@ productP_v = closure1 (scalar_fold (*) 1) (scalar_folds (*) 1)
 
 (/) :: Double -> Double -> Double
 (/) = (P./)
 
 (/) :: Double -> Double -> Double
 (/) = (P./)
-{-# VECTORISE SCALAR (/) #-}
 
 recip :: Double -> Double
 recip = P.recip
 
 recip :: Double -> Double
 recip = P.recip
-{-# VECTORISE SCALAR recip #-}
 
 pi :: Double
 pi = P.pi
 
 pi :: Double
 pi = P.pi
@@ -153,52 +139,30 @@ pi = P.pi
 exp, sqrt, log, sin, tan, cos, asin, atan, acos, sinh, tanh, cosh,
   asinh, atanh, acosh :: Double -> Double
 exp = P.exp
 exp, sqrt, log, sin, tan, cos, asin, atan, acos, sinh, tanh, cosh,
   asinh, atanh, acosh :: Double -> Double
 exp = P.exp
-{-# VECTORISE SCALAR exp #-}
 sqrt = P.sqrt
 sqrt = P.sqrt
-{-# VECTORISE SCALAR sqrt #-}
 log = P.log
 log = P.log
-{-# VECTORISE SCALAR log #-}
 sin = P.sin
 sin = P.sin
-{-# VECTORISE SCALAR sin #-}
 tan = P.tan
 tan = P.tan
-{-# VECTORISE SCALAR tan #-}
 cos = P.cos
 cos = P.cos
-{-# VECTORISE SCALAR cos #-}
 asin = P.asin
 asin = P.asin
-{-# VECTORISE SCALAR asin #-}
 atan = P.atan
 atan = P.atan
-{-# VECTORISE SCALAR atan #-}
 acos = P.acos
 acos = P.acos
-{-# VECTORISE SCALAR acos #-}
 sinh = P.sinh
 sinh = P.sinh
-{-# VECTORISE SCALAR sinh #-}
 tanh = P.tanh
 tanh = P.tanh
-{-# VECTORISE SCALAR tanh #-}
 cosh = P.cosh
 cosh = P.cosh
-{-# VECTORISE SCALAR cosh #-}
 asinh = P.asinh
 asinh = P.asinh
-{-# VECTORISE SCALAR asinh #-}
 atanh = P.atanh
 atanh = P.atanh
-{-# VECTORISE SCALAR atanh #-}
 acosh = P.acosh
 acosh = P.acosh
-{-# VECTORISE SCALAR acosh #-}
 
 (**), logBase :: Double -> Double -> Double
 (**) = (P.**)
 
 (**), logBase :: Double -> Double -> Double
 (**) = (P.**)
-{-# VECTORISE SCALAR (**) #-}
 logBase = P.logBase
 logBase = P.logBase
-{-# VECTORISE SCALAR logBase #-}
 
 fromInt :: Int -> Double
 fromInt = P.fromIntegral
 
 fromInt :: Int -> Double
 fromInt = P.fromIntegral
-{-# VECTORISE SCALAR fromInt #-}
 
 truncate, round, ceiling, floor :: Double -> Int
 truncate = P.truncate
 
 truncate, round, ceiling, floor :: Double -> Int
 truncate = P.truncate
-{-# VECTORISE SCALAR truncate #-}
 round = P.round
 round = P.round
-{-# VECTORISE SCALAR round #-}
 ceiling = P.ceiling
 ceiling = P.ceiling
-{-# VECTORISE SCALAR ceiling #-}
 floor = P.floor
 floor = P.floor
-{-# VECTORISE SCALAR floor #-}
index 0d52190..8a36907 100644 (file)
@@ -36,6 +36,7 @@ import Data.Array.Parallel.Lifted.Scalar
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
+import Prelude (Int, Float)
 
 
 infixr 8 **
 
 
 infixr 8 **
@@ -46,23 +47,15 @@ infix 4 ==, /=, <, <=, >, >=
 
 (==), (/=), (<), (<=), (>), (>=) :: Float -> Float -> Bool
 (==) = (P.==)
 
 (==), (/=), (<), (<=), (>), (>=) :: Float -> Float -> Bool
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
 
 min, max :: Float -> Float -> Float
 min = P.min
 
 min, max :: Float -> Float -> Float
 min = P.min
-{-# VECTORISE SCALAR min #-}
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
 
 minimumP, maximumP :: PArr Float -> Float
 {-# NOINLINE minimumP #-}
 
 minimumP, maximumP :: PArr Float -> Float
 {-# NOINLINE minimumP #-}
@@ -110,17 +103,12 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 (+), (-), (*) :: Float -> Float -> Float
 (+) = (P.+)
 
 (+), (-), (*) :: Float -> Float -> Float
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
 
 negate, abs :: Float -> Float
 negate = P.negate
 
 negate, abs :: Float -> Float
 negate = P.negate
-{-# VECTORISE SCALAR negate #-}
 abs = P.abs
 abs = P.abs
-{-# VECTORISE SCALAR abs #-}
 
 sumP, productP :: PArr Float -> Float
 {-# NOINLINE sumP #-}
 
 sumP, productP :: PArr Float -> Float
 {-# NOINLINE sumP #-}
@@ -140,11 +128,9 @@ productP_v = closure1 (scalar_fold (*) 1) (scalar_folds (*) 1)
 
 (/) :: Float -> Float -> Float
 (/) = (P./)
 
 (/) :: Float -> Float -> Float
 (/) = (P./)
-{-# VECTORISE SCALAR (/) #-}
 
 recip :: Float -> Float
 recip = P.recip
 
 recip :: Float -> Float
 recip = P.recip
-{-# VECTORISE SCALAR recip #-}
 
 pi :: Float
 pi = P.pi
 
 pi :: Float
 pi = P.pi
@@ -153,52 +139,30 @@ pi = P.pi
 exp, sqrt, log, sin, tan, cos, asin, atan, acos, sinh, tanh, cosh,
   asinh, atanh, acosh :: Float -> Float
 exp = P.exp
 exp, sqrt, log, sin, tan, cos, asin, atan, acos, sinh, tanh, cosh,
   asinh, atanh, acosh :: Float -> Float
 exp = P.exp
-{-# VECTORISE SCALAR exp #-}
 sqrt = P.sqrt
 sqrt = P.sqrt
-{-# VECTORISE SCALAR sqrt #-}
 log = P.log
 log = P.log
-{-# VECTORISE SCALAR log #-}
 sin = P.sin
 sin = P.sin
-{-# VECTORISE SCALAR sin #-}
 tan = P.tan
 tan = P.tan
-{-# VECTORISE SCALAR tan #-}
 cos = P.cos
 cos = P.cos
-{-# VECTORISE SCALAR cos #-}
 asin = P.asin
 asin = P.asin
-{-# VECTORISE SCALAR asin #-}
 atan = P.atan
 atan = P.atan
-{-# VECTORISE SCALAR atan #-}
 acos = P.acos
 acos = P.acos
-{-# VECTORISE SCALAR acos #-}
 sinh = P.sinh
 sinh = P.sinh
-{-# VECTORISE SCALAR sinh #-}
 tanh = P.tanh
 tanh = P.tanh
-{-# VECTORISE SCALAR tanh #-}
 cosh = P.cosh
 cosh = P.cosh
-{-# VECTORISE SCALAR cosh #-}
 asinh = P.asinh
 asinh = P.asinh
-{-# VECTORISE SCALAR asinh #-}
 atanh = P.atanh
 atanh = P.atanh
-{-# VECTORISE SCALAR atanh #-}
 acosh = P.acosh
 acosh = P.acosh
-{-# VECTORISE SCALAR acosh #-}
 
 (**), logBase :: Float -> Float -> Float
 (**) = (P.**)
 
 (**), logBase :: Float -> Float -> Float
 (**) = (P.**)
-{-# VECTORISE SCALAR (**) #-}
 logBase = P.logBase
 logBase = P.logBase
-{-# VECTORISE SCALAR logBase #-}
 
 fromInt :: Int -> Float
 fromInt = P.fromIntegral
 
 fromInt :: Int -> Float
 fromInt = P.fromIntegral
-{-# VECTORISE SCALAR fromInt #-}
 
 truncate, round, ceiling, floor :: Float -> Int
 truncate = P.truncate
 
 truncate, round, ceiling, floor :: Float -> Int
 truncate = P.truncate
-{-# VECTORISE SCALAR truncate #-}
 round = P.round
 round = P.round
-{-# VECTORISE SCALAR round #-}
 ceiling = P.ceiling
 ceiling = P.ceiling
-{-# VECTORISE SCALAR ceiling #-}
 floor = P.floor
 floor = P.floor
-{-# VECTORISE SCALAR floor #-}
index 3037fb1..4230a0c 100644 (file)
@@ -30,6 +30,7 @@ import Data.Array.Parallel.Lifted.Scalar
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
+import Prelude (Int)
 
 
 infixl 7 *
 
 
 infixl 7 *
@@ -40,23 +41,15 @@ infixl 7 `div`, `mod`
 
 (==), (/=), (<), (<=), (>), (>=) :: Int -> Int -> Bool
 (==) = (P.==)
 
 (==), (/=), (<), (<=), (>), (>=) :: Int -> Int -> Bool
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
 
 min, max :: Int -> Int -> Int
 min = P.min
 
 min, max :: Int -> Int -> Int
 min = P.min
-{-# VECTORISE SCALAR min #-}
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
 
 minimumP, maximumP :: PArr Int -> Int
 {-# NOINLINE minimumP #-}
 
 minimumP, maximumP :: PArr Int -> Int
 {-# NOINLINE minimumP #-}
@@ -104,17 +97,12 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 (+), (-), (*) :: Int -> Int -> Int
 (+) = (P.+)
 
 (+), (-), (*) :: Int -> Int -> Int
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
 
 negate, abs :: Int -> Int
 negate = P.negate
 
 negate, abs :: Int -> Int
 negate = P.negate
-{-# VECTORISE SCALAR negate #-}
 abs = P.abs
 abs = P.abs
-{-# VECTORISE SCALAR abs #-}
 
 sumP, productP :: PArr Int -> Int
 {-# NOINLINE sumP #-}
 
 sumP, productP :: PArr Int -> Int
 {-# NOINLINE sumP #-}
@@ -134,13 +122,10 @@ productP_v = closure1 (scalar_fold (P.*) 1) (scalar_folds (P.*) 1)
 
 div, mod :: Int -> Int -> Int
 div = P.div
 
 div, mod :: Int -> Int -> Int
 div = P.div
-{-# VECTORISE SCALAR div #-}
 mod = P.mod
 mod = P.mod
-{-# VECTORISE SCALAR mod #-}
 
 sqrt ::  Int -> Int
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
 
 sqrt ::  Int -> Int
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
-{-# VECTORISE SCALAR sqrt #-}
 
 enumFromToP :: Int -> Int ->  PArr Int
 {-# NOINLINE enumFromToP #-}
 
 enumFromToP :: Int -> Int ->  PArr Int
 {-# NOINLINE enumFromToP #-}
index 286b1f8..abc987f 100644 (file)
@@ -28,6 +28,9 @@ import Data.Array.Parallel.Lifted.Scalar
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
 import Data.Array.Parallel.Lifted.Closure
 
 import qualified Prelude as P
+import Prelude (Int)
+
+import Data.Word (Word8)
 
 
 infixl 7 *
 
 
 infixl 7 *
@@ -38,23 +41,15 @@ infixl 7 `div`, `mod`
 
 (==), (/=), (<), (<=), (>), (>=) :: Word8 -> Word8 -> Bool
 (==) = (P.==)
 
 (==), (/=), (<), (<=), (>), (>=) :: Word8 -> Word8 -> Bool
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
 
 min, max :: Word8 -> Word8 -> Word8
 min = P.min
 
 min, max :: Word8 -> Word8 -> Word8
 min = P.min
-{-# VECTORISE SCALAR min #-}
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
 
 minimumP, maximumP :: PArr Word8 -> Word8
 {-# NOINLINE minimumP #-}
 
 minimumP, maximumP :: PArr Word8 -> Word8
 {-# NOINLINE minimumP #-}
@@ -102,17 +97,12 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 (+), (-), (*) :: Word8 -> Word8 -> Word8
 (+) = (P.+)
 
 (+), (-), (*) :: Word8 -> Word8 -> Word8
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
 
 negate, abs :: Word8 -> Word8
 negate = P.negate
 
 negate, abs :: Word8 -> Word8
 negate = P.negate
-{-# VECTORISE SCALAR negate #-}
 abs = P.abs
 abs = P.abs
-{-# VECTORISE SCALAR abs #-}
 
 sumP, productP :: PArr Word8 -> Word8
 {-# NOINLINE sumP #-}
 
 sumP, productP :: PArr Word8 -> Word8
 {-# NOINLINE sumP #-}
@@ -132,18 +122,13 @@ productP_v = closure1 (scalar_fold (*) 1) (scalar_folds (*) 1)
 
 div, mod :: Word8 -> Word8 -> Word8
 div = P.div
 
 div, mod :: Word8 -> Word8 -> Word8
 div = P.div
-{-# VECTORISE SCALAR div #-}
 mod = P.mod
 mod = P.mod
-{-# VECTORISE SCALAR mod #-}
 
 sqrt ::  Word8 -> Word8
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
 
 sqrt ::  Word8 -> Word8
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
-{-# VECTORISE SCALAR sqrt #-}
 
 toInt :: Word8 -> Int
 toInt = P.fromIntegral
 
 toInt :: Word8 -> Int
 toInt = P.fromIntegral
-{-# VECTORISE SCALAR toInt #-}
 
 fromInt :: Int -> Word8
 fromInt = P.fromIntegral
 
 fromInt :: Int -> Word8
 fromInt = P.fromIntegral
-{-# VECTORISE SCALAR fromInt #-}
index d0ce375..430f8e1 100644 (file)
@@ -3,11 +3,9 @@
 -- |This module sets up the basic vectorisation map for vectorising the DPH Prelude.
 module Data.Array.Parallel.Prelude.Base
         ( PArr
 -- |This module sets up the basic vectorisation map for vectorising the DPH Prelude.
 module Data.Array.Parallel.Prelude.Base
         ( PArr
-        -- , ()
+        -- , (->), ()
         , Bool(..)
         , Ordering(..)
         , Bool(..)
         , Ordering(..)
-        , Word8, Int
-        , Float, Double
         , Eq(..), Ord(..)
         , Show
         , Num(..)
         , Eq(..), Ord(..)
         , Show
         , Num(..)
@@ -19,28 +17,22 @@ import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.Lifted.Closure
 
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.Lifted.Closure
 
-import Data.Word (Word8)
-
 
 -- internal types
 
 -- internal types
-{-# VECTORISE SCALAR type PArr = PArray #-}
-{-# VECTORISE SCALAR type PArray = PArray #-}
+{-# VECTORISE type PArr = PArray #-}
+{-# VECTORISE type PArray = PArray #-}
 {-# VECTORISE SCALAR type (->) = (:->) #-}
 
 -- vectorised versions of types from the standard Prelude
 {-# VECTORISE SCALAR type (->) = (:->) #-}
 
 -- vectorised versions of types from the standard Prelude
-{-# VECTORISE type ()       = () #-}
-{-# VECTORISE type Bool     = Bool #-}
-{-# VECTORISE type Ordering = Ordering #-}
-{-# VECTORISE SCALAR type Word8 #-}
-{-# VECTORISE SCALAR type Int #-}
-{-# VECTORISE SCALAR type Float #-}
-{-# VECTORISE SCALAR type Double #-}
+{-# VECTORISE SCALAR type () #-}
+{-# VECTORISE SCALAR type Bool #-}
+{-# VECTORISE SCALAR type Ordering #-}
 
 
--- FIXME: currently a fake definition to allow 'Integer' in SCALAR class instances
-{-# VECTORISE SCALAR type Integer #-}
+-- FIXME: currently a fake definition to allow 'Integer' in vectorised classes
+{-# VECTORISE SCALAR type Integer = Integer #-}
 
 -- vectorised versions of type classes from the standard Prelude
 {-# VECTORISE class Eq #-}
 {-# VECTORISE class Ord #-}
 
 -- vectorised versions of type classes from the standard Prelude
 {-# VECTORISE class Eq #-}
 {-# VECTORISE class Ord #-}
-{-# VECTORISE class Show #-}  -- only to facilitate 'Num', no vectorised instances provided
+{-# VECTORISE class Show #-}  -- only to facilitate 'Num', no vectorised instances provided  
 {-# VECTORISE class Num #-}
 {-# VECTORISE class Num #-}
index 212ccf5..6df3a23 100644 (file)
@@ -9,7 +9,7 @@ where
 -- Primitives needed by the vectoriser.
 import Data.Array.Parallel.Prim
 import Data.Array.Parallel.PArr
 -- Primitives needed by the vectoriser.
 import Data.Array.Parallel.Prim
 import Data.Array.Parallel.PArr
-import Data.Array.Parallel.Prelude.Base                 (Bool(..), Int, Eq, Ord)
+import Data.Array.Parallel.Prelude.Base                 (Bool(..))
 import Data.Array.Parallel.Prelude.Int as I             (sumP, (==), (/=))  -- just temporary
 import Data.Array.Parallel.Lifted                       (mapPP, lengthPP)   -- just temporary
 import Data.Array.Parallel.PArray.PRepr
 import Data.Array.Parallel.Prelude.Int as I             (sumP, (==), (/=))  -- just temporary
 import Data.Array.Parallel.Lifted                       (mapPP, lengthPP)   -- just temporary
 import Data.Array.Parallel.PArray.PRepr
@@ -17,11 +17,8 @@ import Data.Array.Parallel.PArray.PData.Base
 import qualified Data.Array.Parallel.Unlifted           as U
 import Data.Bits
 import qualified Prelude as P
 import qualified Data.Array.Parallel.Unlifted           as U
 import Data.Bits
 import qualified Prelude as P
-        
-        
--- instances of standard type classes from the Prelude 
-{-# VECTORISE SCALAR instance Eq Bool #-}
-{-# VECTORISE SCALAR instance Ord Bool #-}
+import Prelude                                          (Int)
+
 
 -- and ------------------------------------------------------------------------
 {-# VECTORISE (P.&&) = (&&*) #-}
 
 -- and ------------------------------------------------------------------------
 {-# VECTORISE (P.&&) = (&&*) #-}
@@ -130,9 +127,7 @@ lengthP = lengthPArr
 fromBool :: Bool -> Int
 fromBool False = 0
 fromBool True  = 1
 fromBool :: Bool -> Int
 fromBool False = 0
 fromBool True  = 1
-{-# VECTORISE SCALAR fromBool #-}
 
 toBool :: Int -> Bool
 toBool 0 = False
 toBool _ = True
 
 toBool :: Int -> Bool
 toBool 0 = False
 toBool _ = True
-{-# VECTORISE SCALAR toBool #-}
index 6fe6726..8515ce6 100644 (file)
@@ -28,18 +28,14 @@ module Data.Array.Parallel.Prelude.Double
 where
 -- Primitives needed by the vectoriser.
 import Data.Array.Parallel.Prim                 ()      
 where
 -- Primitives needed by the vectoriser.
 import Data.Array.Parallel.Prim                 ()      
-import Data.Array.Parallel.Prelude.Base         (Bool, Int, Double, Eq, Ord, Num)
+import Data.Array.Parallel.Prelude.Base         (Bool)
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray
 import Data.Array.Parallel.Lifted                       ((:->)(..))
 import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 import qualified Prelude as P
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray
 import Data.Array.Parallel.Lifted                       ((:->)(..))
 import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 import qualified Prelude as P
-
-
-{-# VECTORISE SCALAR instance Eq  Double #-}
-{-# VECTORISE SCALAR instance Ord Double #-}
-{-# VECTORISE SCALAR instance Num Double #-}
+import Prelude                                          (Int, Double)
 
 
 infixl 7 *, /
 
 
 infixl 7 *, /
@@ -48,35 +44,17 @@ infix  4 ==, /=, <, <=, >, >=
 
 -- Ord ------------------------------------------------------------------------
 (==), (/=), (<), (<=), (>), (>=) :: Double -> Double -> Bool
 
 -- Ord ------------------------------------------------------------------------
 (==), (/=), (<), (<=), (>), (>=) :: Double -> Double -> Bool
-
 (==) = (P.==)
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
-
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
-
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
-
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
-
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
-
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
-
 
 -- min/max ----------------------------
 min, max :: Double -> Double -> Double
 
 -- min/max ----------------------------
 min, max :: Double -> Double -> Double
-
 min = P.min
 min = P.min
-{-# VECTORISE SCALAR min #-}
-
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
-
 
 -- minimum/maximum --------------------
 minimumP, maximumP :: PArr Double -> Double
 
 -- minimum/maximum --------------------
 minimumP, maximumP :: PArr Double -> Double
@@ -134,28 +112,15 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 -- Num ---------------------------------------------------------------------
 (+), (-), (*), (/) :: Double -> Double -> Double
 
 -- Num ---------------------------------------------------------------------
 (+), (-), (*), (/) :: Double -> Double -> Double
-
 (+) = (P.+)
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
-
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
-
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
-
 (/) = (P./)
 (/) = (P./)
-{-# VECTORISE SCALAR (/) #-}
 
 -- negate/abs -------------------------
 negate, abs :: Double -> Double
 
 -- negate/abs -------------------------
 negate, abs :: Double -> Double
-
 negate  = P.negate
 negate  = P.negate
-{-# VECTORISE SCALAR negate #-}
-
 abs     = P.abs
 abs     = P.abs
-{-# VECTORISE SCALAR abs #-}
-
 
 -- sum/product ------------------------
 sumP, productP :: PArr Double -> Double
 
 -- sum/product ------------------------
 sumP, productP :: PArr Double -> Double
@@ -190,61 +155,25 @@ sqrt,    exp,  log,
  asinh, atanh, acosh  :: Double -> Double
 
 exp = P.exp
  asinh, atanh, acosh  :: Double -> Double
 
 exp = P.exp
-{-# VECTORISE SCALAR exp #-}
-
 sqrt = P.sqrt
 sqrt = P.sqrt
-{-# VECTORISE SCALAR sqrt #-}
-
 log = P.log
 log = P.log
-{-# VECTORISE SCALAR log #-}
-
 sin = P.sin
 sin = P.sin
-{-# VECTORISE SCALAR sin #-}
-
 tan = P.tan
 tan = P.tan
-{-# VECTORISE SCALAR tan #-}
-
 cos = P.cos
 cos = P.cos
-{-# VECTORISE SCALAR cos #-}
-
 asin = P.asin
 asin = P.asin
-{-# VECTORISE SCALAR asin #-}
-
 atan = P.atan
 atan = P.atan
-{-# VECTORISE SCALAR atan #-}
-
 acos = P.acos
 acos = P.acos
-{-# VECTORISE SCALAR acos #-}
-
 sinh = P.sinh
 sinh = P.sinh
-{-# VECTORISE SCALAR sinh #-}
-
 tanh = P.tanh
 tanh = P.tanh
-{-# VECTORISE SCALAR tanh #-}
-
 cosh = P.cosh
 cosh = P.cosh
-{-# VECTORISE SCALAR cosh #-}
-
 asinh = P.asinh
 asinh = P.asinh
-{-# VECTORISE SCALAR asinh #-}
-
 atanh = P.atanh
 atanh = P.atanh
-{-# VECTORISE SCALAR atanh #-}
-
 acosh = P.acosh
 acosh = P.acosh
-{-# VECTORISE SCALAR acosh #-}
-
 
 (**), logBase :: Double -> Double -> Double
 
 (**), logBase :: Double -> Double -> Double
-
 (**)    = (P.**)
 (**)    = (P.**)
-{-# VECTORISE SCALAR (**) #-}
-
 logBase = P.logBase
 logBase = P.logBase
-{-# VECTORISE SCALAR logBase #-}
-
 
 -- RealFrac -------------------------------------------------------------------
 fromInt :: Int -> Double
 
 -- RealFrac -------------------------------------------------------------------
 fromInt :: Int -> Double
-fromInt         = P.fromIntegral
-{-# VECTORISE SCALAR fromInt #-}
+fromInt = P.fromIntegral
index 259bec0..42ed218 100644 (file)
@@ -21,19 +21,14 @@ module Data.Array.Parallel.Prelude.Int
 where
 -- Primitives needed by the vectoriser.
 import Data.Array.Parallel.Prim                         ()      
 where
 -- Primitives needed by the vectoriser.
 import Data.Array.Parallel.Prim                         ()      
-import Data.Array.Parallel.Prelude.Base                 (Bool, Int, Eq, Ord, Num)
+import Data.Array.Parallel.Prelude.Base                 (Bool)
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray
 import Data.Array.Parallel.Lifted                       ((:->)(..))
 import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 import qualified Prelude as P
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray
 import Data.Array.Parallel.Lifted                       ((:->)(..))
 import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 import qualified Prelude as P
-        
-
-{-# VECTORISE SCALAR instance Eq  Int #-}
-{-# VECTORISE SCALAR instance Ord Int #-}
-{-# VECTORISE SCALAR instance Num Int #-}
-
+import Prelude (Int)
 
 infixl 7 *
 infixl 6 +, -
 
 infixl 7 *
 infixl 6 +, -
@@ -42,34 +37,18 @@ infixl 7 `div`, `mod`
 
 -- Ord ------------------------------------------------------------------------
 (==), (/=), (<), (<=), (>), (>=) :: Int -> Int -> Bool
 
 -- Ord ------------------------------------------------------------------------
 (==), (/=), (<), (<=), (>), (>=) :: Int -> Int -> Bool
-
 (==) = (P.==)
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
-
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
-
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
-
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
-
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
-
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
 
 
 -- min/max ----------------------------
 min, max :: Int -> Int -> Int
 
 
 -- min/max ----------------------------
 min, max :: Int -> Int -> Int
-
 min = P.min
 min = P.min
-{-# VECTORISE SCALAR min #-}
-
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
 
 
 -- minimum/maximum --------------------
 
 
 -- minimum/maximum --------------------
@@ -128,26 +107,15 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 -- Num ------------------------------------------------------------------------
 (+), (-), (*) :: Int -> Int -> Int
 
 -- Num ------------------------------------------------------------------------
 (+), (-), (*) :: Int -> Int -> Int
-
 (+) = (P.+)
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
-
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
-
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
 
 
 -- negate/abs -------------------------
 negate, abs :: Int -> Int
 
 
 -- negate/abs -------------------------
 negate, abs :: Int -> Int
-
 negate  = P.negate
 negate  = P.negate
-{-# VECTORISE SCALAR negate #-}
-
 abs     = P.abs
 abs     = P.abs
-{-# VECTORISE SCALAR abs #-}
-
 
 -- sum/product ------------------------
 sumP, productP :: PArr Int -> Int
 
 -- sum/product ------------------------
 sumP, productP :: PArr Int -> Int
@@ -172,18 +140,11 @@ productPP      = L.closure1' (SC.fold (*) 1) (SC.folds (*) 1)
 
 -- Integral -------------------------------------------------------------------
 div, mod :: Int -> Int -> Int
 
 -- Integral -------------------------------------------------------------------
 div, mod :: Int -> Int -> Int
-
 div = P.div
 div = P.div
-{-# VECTORISE SCALAR div #-}
-
 mod = P.mod
 mod = P.mod
-{-# VECTORISE SCALAR mod #-}
-
 
 sqrt :: Int -> Int 
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
 
 sqrt :: Int -> Int 
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
-{-# VECTORISE SCALAR sqrt #-}
-
 
 -- Enum -----------------------------------------------------------------------
 enumFromToP :: Int -> Int -> PArr Int
 
 -- Enum -----------------------------------------------------------------------
 enumFromToP :: Int -> Int -> PArr Int
index 977d131..b6bfe90 100644 (file)
@@ -14,10 +14,6 @@ import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 
 
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 
 
-{-# VECTORISE SCALAR instance Eq  Ordering #-}
-{-# VECTORISE SCALAR instance Ord Ordering #-}
-
-
 isLT, isEQ, isGT :: Ordering -> Bool
 
 isLT _  = False
 isLT, isEQ, isGT :: Ordering -> Bool
 
 isLT _  = False
index b7a2f50..7cef2ee 100644 (file)
@@ -21,19 +21,16 @@ module Data.Array.Parallel.Prelude.Word8
         , toInt)
 where
 import Data.Array.Parallel.Prim                         ()      
         , toInt)
 where
 import Data.Array.Parallel.Prim                         ()      
-import Data.Array.Parallel.Prelude.Base                 (Bool, Int, Word8, Eq, Ord, Num)
+import Data.Array.Parallel.Prelude.Base                 (Bool)
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray
 import Data.Array.Parallel.Lifted                       ((:->)(..))
 import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 import qualified Prelude as P
 import Data.Array.Parallel.PArr
 import Data.Array.Parallel.PArray
 import Data.Array.Parallel.Lifted                       ((:->)(..))
 import qualified Data.Array.Parallel.Lifted             as L
 import qualified Data.Array.Parallel.PArray.Scalar      as SC
 import qualified Prelude as P
+import Prelude                                          (Int)
 
 
-
-{-# VECTORISE SCALAR instance Eq  Word8 #-}
-{-# VECTORISE SCALAR instance Ord Word8 #-}
-{-# VECTORISE SCALAR instance Num Word8 #-}
-
+import Data.Word                                        (Word8)
 
 infixl 7 *
 infixl 6 +, -
 
 infixl 7 *
 infixl 6 +, -
@@ -42,35 +39,17 @@ infixl 7 `div`, `mod`
 
 -- Ord ------------------------------------------------------------------------
 (==), (/=), (<), (<=), (>), (>=) :: Word8 -> Word8 -> Bool
 
 -- Ord ------------------------------------------------------------------------
 (==), (/=), (<), (<=), (>), (>=) :: Word8 -> Word8 -> Bool
-
 (==) = (P.==)
 (==) = (P.==)
-{-# VECTORISE SCALAR (==) #-}
-
 (/=) = (P./=)
 (/=) = (P./=)
-{-# VECTORISE SCALAR (/=) #-}
-
 (<=) = (P.<=)
 (<=) = (P.<=)
-{-# VECTORISE SCALAR (<=) #-}
-
 (<)  = (P.<)
 (<)  = (P.<)
-{-# VECTORISE SCALAR (<) #-}
-
 (>=) = (P.>=)
 (>=) = (P.>=)
-{-# VECTORISE SCALAR (>=) #-}
-
 (>)  = (P.>)
 (>)  = (P.>)
-{-# VECTORISE SCALAR (>) #-}
-
 
 -- min/max ----------------------------
 min, max :: Word8 -> Word8 -> Word8
 
 -- min/max ----------------------------
 min, max :: Word8 -> Word8 -> Word8
-
 min = P.min
 min = P.min
-{-# VECTORISE SCALAR min #-}
-
 max = P.max
 max = P.max
-{-# VECTORISE SCALAR max #-}
-
 
 -- minimum/maximum --------------------
 minimumP, maximumP :: PArr Word8 -> Word8
 
 -- minimum/maximum --------------------
 minimumP, maximumP :: PArr Word8 -> Word8
@@ -128,26 +107,14 @@ max' (i,x) (j,y) | x P.>= y    = (i,x)
 
 -- Num ------------------------------------------------------------------------
 (+), (-), (*) :: Word8 -> Word8 -> Word8
 
 -- Num ------------------------------------------------------------------------
 (+), (-), (*) :: Word8 -> Word8 -> Word8
-
 (+) = (P.+)
 (+) = (P.+)
-{-# VECTORISE SCALAR (+) #-}
-
 (-) = (P.-)
 (-) = (P.-)
-{-# VECTORISE SCALAR (-) #-}
-
 (*) = (P.*)
 (*) = (P.*)
-{-# VECTORISE SCALAR (*) #-}
-
 
 -- negate/abs -------------------------
 negate, abs :: Word8 -> Word8
 
 -- negate/abs -------------------------
 negate, abs :: Word8 -> Word8
-
 negate  = P.negate
 negate  = P.negate
-{-# VECTORISE SCALAR negate #-}
-
 abs     = P.abs
 abs     = P.abs
-{-# VECTORISE SCALAR abs #-}
-
 
 -- sum/product ------------------------
 sumP, productP :: PArr Word8 -> Word8
 
 -- sum/product ------------------------
 sumP, productP :: PArr Word8 -> Word8
@@ -172,24 +139,15 @@ productPP      = L.closure1' (SC.fold (*) 1) (SC.folds (*) 1)
 
 -- Integral -------------------------------------------------------------------
 div, mod :: Word8 -> Word8 -> Word8
 
 -- Integral -------------------------------------------------------------------
 div, mod :: Word8 -> Word8 -> Word8
-
 div = P.div
 div = P.div
-{-# VECTORISE SCALAR div #-}
-
 mod = P.mod
 mod = P.mod
-{-# VECTORISE SCALAR mod #-}
-
 
 sqrt :: Word8 -> Word8 
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
 
 sqrt :: Word8 -> Word8 
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
-{-# VECTORISE SCALAR sqrt #-}
-
 
 -- Conversion -----------------------------------------------------------------
 toInt :: Word8 -> Int
 toInt = P.fromIntegral
 
 -- Conversion -----------------------------------------------------------------
 toInt :: Word8 -> Int
 toInt = P.fromIntegral
-{-# VECTORISE SCALAR toInt #-}
 
 fromInt :: Int -> Word8
 fromInt = P.fromIntegral
 
 fromInt :: Int -> Word8
 fromInt = P.fromIntegral
-{-# VECTORISE SCALAR fromInt #-}