dph-lifted-vseg: add tuple and closure instances up to arity 5
authorBen Lippmeier <benl@ouroborus.net>
Tue, 15 Nov 2011 06:54:43 +0000 (17:54 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Tue, 15 Nov 2011 06:54:43 +0000 (17:54 +1100)
dph-lifted-vseg/Data/Array/Parallel/Lifted/Closure.hs
dph-lifted-vseg/Data/Array/Parallel/PArray.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple3.hs [new file with mode: 0644]
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple4.hs [new file with mode: 0644]
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple5.hs [new file with mode: 0644]
dph-lifted-vseg/Data/Array/Parallel/PArray/PRepr/Tuple.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Tuple.hs
dph-lifted-vseg/Data/Array/Parallel/Prim.hs
dph-lifted-vseg/dph-lifted-vseg.cabal

index fffd991..81c51e0 100644 (file)
@@ -12,13 +12,15 @@ module Data.Array.Parallel.Lifted.Closure
         , ($:^), liftedApply
 
         -- * Closure Construction.
-        , closure1,  closure2,  closure3
-        , closure1', closure2', closure3')
+        , closure1,  closure2,  closure3,  closure4,  closure5
+        , closure1', closure2', closure3', closure4', closure5')
 where
 import Data.Array.Parallel.Pretty
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.PArray.PData.Unit
 import Data.Array.Parallel.PArray.PData.Tuple2
+import Data.Array.Parallel.PArray.PData.Tuple3
+import Data.Array.Parallel.PArray.PData.Tuple4
 import Data.Array.Parallel.PArray.PRepr
 import qualified Data.Vector            as V
 import GHC.Exts
@@ -154,6 +156,59 @@ closure3 fv fl
 {-# INLINE_CLOSURE closure3 #-}
 
 
+-- | Construct an arity-4 closure
+--   from lifted and unlifted versions of a primitive function.
+closure4 
+        :: forall a b c d e. (PA a, PA b, PA c)
+        => (a -> b -> c -> d -> e)
+        -> (Int -> PData a -> PData b -> PData c -> PData d -> PData e)
+        -> (a :-> b :-> c :-> d :-> e)
+        
+closure4 fv fl
+ = let  fv_1   _ xa                   = Clo  fv_2 fl_2 xa
+        fl_1 _ _ xs                   = AClo fv_2 fl_2 xs
+
+        fv_2   xa yb                  = Clo  fv_3 fl_3 (xa, yb)
+        fl_2 _ xs ys                  = AClo fv_3 fl_3 (PTuple2 xs ys)
+
+        fv_3 (xa, yb) zc              = Clo  fv_4 fl_4 (xa, yb, zc)
+        fl_3 _ (PTuple2 xs ys) zs     = AClo fv_4 fl_4 (PTuple3 xs ys zs)
+
+        fv_4 (xa, yb, zc) ad          = fv xa yb zc ad
+        fl_4 n (PTuple3 xs ys zs) as  = fl n xs ys zs as
+
+   in   Clo fv_1 fl_1 ()
+{-# INLINE_CLOSURE closure4 #-}
+
+
+-- | Construct an arity-5 closure
+--   from lifted and unlifted versions of a primitive function.
+closure5
+        :: forall a b c d e f. (PA a, PA b, PA c, PA d)
+        => (a -> b -> c -> d -> e -> f)
+        -> (Int -> PData a -> PData b -> PData c -> PData d -> PData e -> PData f)
+        -> (a :-> b :-> c :-> d :-> e :-> f)
+        
+closure5 fv fl
+ = let  fv_1   _ xa                     = Clo  fv_2 fl_2 xa
+        fl_1 _ _ xs                     = AClo fv_2 fl_2 xs
+
+        fv_2   xa yb                    = Clo  fv_3 fl_3 (xa, yb)
+        fl_2 _ xs ys                    = AClo fv_3 fl_3 (PTuple2 xs ys)
+
+        fv_3 (xa, yb) zc                = Clo  fv_4 fl_4 (xa, yb, zc)
+        fl_3 _ (PTuple2 xs ys) zs       = AClo fv_4 fl_4 (PTuple3 xs ys zs)
+
+        fv_4 (xa, yb, zc) ad            = Clo  fv_5 fl_5 (xa, yb, zc, ad)
+        fl_4 _ (PTuple3 xs ys zs) as    = AClo fv_5 fl_5 (PTuple4 xs ys zs as)
+
+        fv_5 (xa, yb, zc, ad) be        = fv xa yb zc ad be
+        fl_5 n (PTuple4 xs ys zs as) bs = fl n xs ys zs as bs
+
+   in   Clo fv_1 fl_1 ()
+{-# INLINE_CLOSURE closure5 #-}
+
+
 -- Closure constructors that take PArrays -------------------------------------
 -- These versions are useful when defining prelude functions such as in 
 -- D.A.P.Prelude.Int. They let us promote functions that work on PArrays 
@@ -207,6 +262,38 @@ closure3' fv fl
 {-# INLINE_CLOSURE closure3' #-}
 
 
+-- | Construct an arity-4 closure.
+closure4'
+        :: forall a b c d e. (PA a, PA b, PA c) 
+        => (a -> b -> c -> d -> e)
+        -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e)
+        -> (a :-> b :-> c :-> d :-> e) 
+
+closure4' fv fl 
+ = let  {-# INLINE fl' #-}
+        fl' (I# n#) pdata1 pdata2 pdata3 pdata4
+         = case fl (PArray n# pdata1) (PArray n# pdata2) (PArray n# pdata3) (PArray n# pdata4) of
+                 PArray _ pdata' -> pdata'
+   in   closure4 fv fl'
+{-# INLINE_CLOSURE closure4' #-}
+
+
+-- | Construct an arity-5 closure.
+closure5'
+        :: forall a b c d e f. (PA a, PA b, PA c, PA d) 
+        => (a -> b -> c -> d -> e -> f)
+        -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f)
+        -> (a :-> b :-> c :-> d :-> e :-> f) 
+
+closure5' fv fl 
+ = let  {-# INLINE fl' #-}
+        fl' (I# n#) pdata1 pdata2 pdata3 pdata4 pdata5
+         = case fl (PArray n# pdata1) (PArray n# pdata2) (PArray n# pdata3) (PArray n# pdata4) (PArray n# pdata5) of
+                 PArray _ pdata' -> pdata'
+   in   closure5 fv fl'
+{-# INLINE_CLOSURE closure5' #-}
+
+
 -- PData instance for closures ------------------------------------------------
 -- This needs to be here instead of in a module D.A.P.PArray.PData.Closure
 -- to break an import loop.
index 61d0300..3296baa 100644 (file)
@@ -53,6 +53,9 @@ module Data.Array.Parallel.PArray
 
         -- * Tuples
         , zip,          zipl
+        , zip3
+        , zip4
+        , zip5
         , unzip,        unzipl
 
         -- * Conversions
@@ -79,7 +82,7 @@ import qualified Prelude                        as P
 import Prelude hiding 
         ( length, replicate, concat
         , enumFromTo
-        , zip, unzip)
+        , zip, zip3, unzip)
 
 
 -- Pretty ---------------------------------------------------------------------
@@ -444,6 +447,31 @@ zipl    :: (PA a, PA b)
         => PArray (PArray a) -> PArray (PArray b) -> PArray (PArray (a, b))
 zipl (PArray n# xs) (PArray _ ys)
         = PArray n# $ ziplPA xs ys
+{-# INLINE_PA zipl #-}
+
+
+-- | O(1). Zip three arrays.
+--   All arrays must have the same length, else `error`. 
+zip3 :: PArray a -> PArray b -> PArray c -> PArray (a, b, c)
+zip3 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3)
+        = PArray n# $ zip3PD pdata1 pdata2 pdata3
+{-# INLINE_PA zip3 #-}
+
+
+-- | O(1). Zip four arrays.
+--   All arrays must have the same length, else `error`. 
+zip4 :: PArray a -> PArray b -> PArray c -> PArray d -> PArray (a, b, c, d)
+zip4 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3) (PArray _ pdata4)
+        = PArray n# $ zip4PD pdata1 pdata2 pdata3 pdata4
+{-# INLINE_PA zip4 #-}
+
+
+-- | O(1). Zip five arrays.
+--   All arrays must have the same length, else `error`. 
+zip5 :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray (a, b, c, d, e)
+zip5 (PArray n# pdata1) (PArray _ pdata2) (PArray _ pdata3) (PArray _ pdata4) (PArray _ pdata5)
+        = PArray n# $ zip5PD pdata1 pdata2 pdata3 pdata4 pdata5
+{-# INLINE_PA zip5 #-}
 
 
 -- | O(1). Unzip an array of pairs into a pair of arrays.
@@ -457,7 +485,7 @@ unzip (PArray n# (PTuple2 xs ys))
 unzipl :: PArray (PArray (a, b)) -> PArray (PArray a, PArray b)
 unzipl (PArray n# pdata)
         = PArray n# $ unziplPD pdata
-
+{-# INLINE_PA unzipl #-}
 
 
 -- Conversions ----------------------------------------------------------------
index ebda201..0be3ce6 100644 (file)
@@ -20,12 +20,18 @@ module Data.Array.Parallel.PArray.PData
         , module Data.Array.Parallel.PArray.PData.Nested
 
         -- * Tuple arrays
-        , module Data.Array.Parallel.PArray.PData.Tuple2)
+        , module Data.Array.Parallel.PArray.PData.Tuple2
+        , module Data.Array.Parallel.PArray.PData.Tuple3
+        , module Data.Array.Parallel.PArray.PData.Tuple4
+        , module Data.Array.Parallel.PArray.PData.Tuple5)
 where
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.PArray.PData.Wrap
 import Data.Array.Parallel.PArray.PData.Nested
 import Data.Array.Parallel.PArray.PData.Tuple2
+import Data.Array.Parallel.PArray.PData.Tuple3
+import Data.Array.Parallel.PArray.PData.Tuple4
+import Data.Array.Parallel.PArray.PData.Tuple5
 import Data.Array.Parallel.PArray.PData.Void            ()
 import Data.Array.Parallel.PArray.PData.Unit            ()
 import Data.Array.Parallel.PArray.PData.Int             ()
diff --git a/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple3.hs b/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple3.hs
new file mode 100644 (file)
index 0000000..c9a6dca
--- /dev/null
@@ -0,0 +1,229 @@
+{-# OPTIONS_HADDOCK hide #-}
+#include "fusion-phases.h"
+
+-- | PR instance for tuples.
+module Data.Array.Parallel.PArray.PData.Tuple3
+        ( PData(..),    PDatas(..)
+        , zip3PD)
+where
+import Data.Array.Parallel.Pretty
+import Data.Array.Parallel.PArray.PData.Base
+import Data.Array.Parallel.PArray.PData.Nested
+import GHC.Exts
+import Prelude hiding (zip, unzip)
+import qualified Data.Vector                    as V
+import qualified Prelude                        as P
+
+-------------------------------------------------------------------------------
+data instance PData (a, b, c)
+        = PTuple3  (PData a) (PData b) (PData c)
+
+data instance PDatas (a, b, c)
+        = PTuple3s (PDatas a) (PDatas b) (PDatas c)
+
+
+-- PR -------------------------------------------------------------------------
+instance (PR a, PR b, PR c) => PR (a, b, c) where
+
+  {-# INLINE_PDATA validPR #-}
+  validPR (PTuple3 xs ys zs)
+        = validPR xs && validPR ys && validPR zs
+
+
+  {-# INLINE_PDATA nfPR #-}
+  nfPR (PTuple3 arr1 arr2 arr3)
+        = nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` ()
+
+
+  {-# INLINE_PDATA similarPR #-}
+  similarPR (x1, y1, z1) (x2, y2, z2)
+        =  similarPR x1 x2
+        && similarPR y1 y2
+        && similarPR z1 z2
+
+
+  {-# INLINE_PDATA coversPR #-}
+  coversPR weak (PTuple3 arr1 arr2 arr3) ix
+        =  coversPR weak arr1 ix
+        && coversPR weak arr2 ix
+        && coversPR weak arr3 ix
+
+  {-# NOINLINE pprpPR #-}
+  pprpPR (x, y, z)
+        = text "Tuple3 "
+        <> vcat [ pprpPR x
+                , pprpPR y
+                , pprpPR z]
+        
+
+  {-# NOINLINE pprpDataPR #-}
+  pprpDataPR (PTuple3 xs ys zs)
+        = text "PTuple3 " 
+        <> vcat [ pprpDataPR xs
+                , pprpDataPR ys
+                , pprpDataPR zs]
+
+
+  -- Constructors -------------------------------
+  {-# INLINE_PDATA emptyPR #-}
+  emptyPR
+        = PTuple3 emptyPR emptyPR emptyPR
+
+
+  {-# INLINE_PDATA replicatePR #-}
+  replicatePR len (x, y, z)
+        = PTuple3 (replicatePR len x)
+                  (replicatePR len y)
+                  (replicatePR len z)
+
+
+  {-# INLINE_PDATA replicatesPR #-}
+  replicatesPR lens (PTuple3 arr1 arr2 arr3)
+        = PTuple3 (replicatesPR lens arr1)
+                  (replicatesPR lens arr2)
+                  (replicatesPR lens arr3)
+
+
+  {-# INLINE_PDATA appendPR #-}
+  appendPR (PTuple3 arr11 arr12 arr13) (PTuple3 arr21 arr22 arr23)
+        = PTuple3 (arr11 `appendPR` arr21)
+                  (arr12 `appendPR` arr22)
+                  (arr13 `appendPR` arr23) 
+
+
+  {-# INLINE_PDATA appendsPR #-}
+  appendsPR segdResult segd1 (PTuple3 arrs11 arrs12 arrs13) segd2 (PTuple3 arrs21 arrs22 arrs23)
+        = PTuple3 (appendsPR segdResult segd1 arrs11 segd2 arrs21)
+                  (appendsPR segdResult segd1 arrs12 segd2 arrs22)
+                  (appendsPR segdResult segd1 arrs13 segd2 arrs23)
+
+
+  -- Projections ---------------------------------
+  {-# INLINE_PDATA lengthPR #-}
+  lengthPR (PTuple3 arr1 _ _) 
+        = lengthPR arr1
+  
+  {-# INLINE_PDATA indexPR #-}
+  indexPR (PTuple3 arr1 arr2 arr3) ix
+        = (indexPR arr1 ix, indexPR arr2 ix, indexPR arr3 ix)
+
+  {-# INLINE_PDATA indexsPR #-}
+  indexsPR (PTuple3s xs ys zs) srcs ixs
+        = PTuple3 (indexsPR xs srcs ixs)
+                  (indexsPR ys srcs ixs)
+                  (indexsPR zs srcs ixs)
+
+  {-# INLINE_PDATA extractPR #-}
+  extractPR (PTuple3 arr1 arr2 arr3) start len
+        = PTuple3 (extractPR arr1 start len) 
+                  (extractPR arr2 start len)
+                  (extractPR arr3 start len)
+
+  {-# INLINE_PDATA extractsPR #-}
+  extractsPR (PTuple3s xs ys zs) ussegd
+        = PTuple3 (extractsPR xs ussegd)
+                  (extractsPR ys ussegd)
+                  (extractsPR zs ussegd)
+
+
+  -- Pack and Combine ---------------------------
+  {-# INLINE_PDATA packByTagPR #-}
+  packByTagPR (PTuple3 arr1 arr2 arr3) tags tag
+        = PTuple3 (packByTagPR arr1 tags tag)
+                  (packByTagPR arr2 tags tag)
+                  (packByTagPR arr3 tags tag)
+
+  {-# INLINE_PDATA combine2PR #-}
+  combine2PR sel (PTuple3 xs1 ys1 zs1) (PTuple3 xs2 ys2 zs2)
+        = PTuple3 (combine2PR sel xs1 xs2)
+                  (combine2PR sel ys1 ys2)
+                  (combine2PR sel zs1 zs2)
+
+
+  -- Conversions --------------------------------
+  {-# INLINE_PDATA fromVectorPR #-}
+  fromVectorPR vec
+   = let (xs, ys, zs)       = V.unzip3 vec
+     in  PTuple3  (fromVectorPR xs)
+                  (fromVectorPR ys)
+                  (fromVectorPR zs)
+
+  {-# INLINE_PDATA toVectorPR #-}
+  toVectorPR (PTuple3 xs ys zs)
+        = V.zip3  (toVectorPR xs)
+                  (toVectorPR ys)
+                  (toVectorPR zs)
+
+
+  -- PData --------------------------------------
+  {-# INLINE_PDATA emptydPR #-}
+  emptydPR      
+        = PTuple3s emptydPR
+                   emptydPR
+                   emptydPR 
+
+  
+  {-# INLINE_PDATA singletondPR #-}
+  singletondPR (PTuple3 x y z)
+        = PTuple3s (singletondPR x)
+                   (singletondPR y)
+                   (singletondPR z)
+
+
+  {-# INLINE_PDATA lengthdPR #-}
+  lengthdPR (PTuple3s xs _ _)
+        = lengthdPR xs
+   
+   
+  {-# INLINE_PDATA indexdPR #-}
+  indexdPR (PTuple3s xs ys zs) i
+        = PTuple3  (indexdPR xs i)
+                   (indexdPR ys i)
+                   (indexdPR zs i)
+
+   
+  {-# INLINE_PDATA appenddPR #-}
+  appenddPR (PTuple3s xs1 ys1 zs1) (PTuple3s xs2 ys2 zs2)
+        = PTuple3s (appenddPR xs1 xs2)
+                   (appenddPR ys1 ys2)
+                   (appenddPR zs1 zs2)
+  
+
+  {-# INLINE_PDATA fromVectordPR #-}
+  fromVectordPR vec
+   = let (xss, yss, zss) = V.unzip3 $ V.map (\(PTuple3 xs ys zs) -> (xs, ys, zs)) vec
+     in  PTuple3s  (fromVectordPR xss)
+                   (fromVectordPR yss)
+                   (fromVectordPR zss)
+
+
+  {-# INLINE_PDATA toVectordPR #-}
+  toVectordPR (PTuple3s pdatas1 pdatas2 pdatas3)
+        = V.zipWith3 PTuple3
+                   (toVectordPR pdatas1)
+                   (toVectordPR pdatas2)
+                   (toVectordPR pdatas3)
+
+-- PD Functions ---------------------------------------------------------------
+-- | O(1). Zip a pair of arrays into an array of pairs.
+zip3PD   :: PData a -> PData b -> PData c -> PData (a, b, c)
+zip3PD   = PTuple3
+{-# INLINE_PA zip3PD #-}
+
+
+-- Show -----------------------------------------------------------------------
+deriving instance (Show (PData  a), Show (PData  b), Show (PData c))
+        => Show (PData  (a, b, c))
+
+deriving instance (Show (PDatas a), Show (PDatas b), Show (PDatas c))
+        => Show (PDatas (a, b, c))
+
+
+instance ( PR a, PR b, PR c, Show a, Show b, Show c
+         , PprVirtual (PData a), PprVirtual (PData b), PprVirtual (PData c))
+        => PprVirtual (PData (a, b, c)) where
+ pprv   (PTuple3 xs ys zs)
+        = text $ show 
+        $ P.zip3 (V.toList $ toVectorPR xs) 
+                 (V.toList $ toVectorPR ys)
+                 (V.toList $ toVectorPR zs)
diff --git a/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple4.hs b/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple4.hs
new file mode 100644 (file)
index 0000000..9bfeb87
--- /dev/null
@@ -0,0 +1,264 @@
+{-# OPTIONS_HADDOCK hide #-}
+#include "fusion-phases.h"
+
+-- | PR instance for tuples.
+module Data.Array.Parallel.PArray.PData.Tuple4
+        ( PData(..),    PDatas(..)
+        , zip4PD)
+where
+import Data.Array.Parallel.Pretty
+import Data.Array.Parallel.PArray.PData.Base
+import Data.Array.Parallel.PArray.PData.Nested
+import GHC.Exts
+import Prelude hiding (zip, unzip)
+import qualified Data.Vector                    as V
+import qualified Prelude                        as P
+import qualified Data.List                      as P
+
+-------------------------------------------------------------------------------
+data instance PData (a, b, c, d)
+        = PTuple4  (PData a) (PData b) (PData c) (PData d)
+
+data instance PDatas (a, b, c, d)
+        = PTuple4s (PDatas a) (PDatas b) (PDatas c) (PDatas d)
+
+
+-- PR -------------------------------------------------------------------------
+instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
+
+  {-# INLINE_PDATA validPR #-}
+  validPR (PTuple4 xs ys zs ds)
+        = validPR xs && validPR ys && validPR zs && validPR ds
+
+
+  {-# INLINE_PDATA nfPR #-}
+  nfPR (PTuple4 arr1 arr2 arr3 arr4)
+        = nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` nfPR arr4 `seq` ()
+
+
+  {-# INLINE_PDATA similarPR #-}
+  similarPR (x1, y1, z1, d1) (x2, y2, z2, d2)
+        =  similarPR x1 x2
+        && similarPR y1 y2
+        && similarPR z1 z2
+        && similarPR d1 d2
+
+
+  {-# INLINE_PDATA coversPR #-}
+  coversPR weak (PTuple4 arr1 arr2 arr3 arr4) ix
+        =  coversPR weak arr1 ix
+        && coversPR weak arr2 ix
+        && coversPR weak arr3 ix
+        && coversPR weak arr4 ix
+
+
+  {-# NOINLINE pprpPR #-}
+  pprpPR (x, y, z, d)
+        = text "Tuple4 "
+        <> vcat [ pprpPR x
+                , pprpPR y
+                , pprpPR z
+                , pprpPR d ]
+        
+
+  {-# NOINLINE pprpDataPR #-}
+  pprpDataPR (PTuple4 xs ys zs ds)
+        = text "PTuple4 " 
+        <> vcat [ pprpDataPR xs
+                , pprpDataPR ys
+                , pprpDataPR zs
+                , pprpDataPR ds]
+
+
+  -- Constructors -------------------------------
+  {-# INLINE_PDATA emptyPR #-}
+  emptyPR
+        = PTuple4 emptyPR emptyPR emptyPR emptyPR
+
+
+  {-# INLINE_PDATA replicatePR #-}
+  replicatePR len (x, y, z, d)
+        = PTuple4 (replicatePR len x)
+                  (replicatePR len y)
+                  (replicatePR len z)
+                  (replicatePR len d)
+
+
+  {-# INLINE_PDATA replicatesPR #-}
+  replicatesPR lens (PTuple4 arr1 arr2 arr3 arr4)
+        = PTuple4 (replicatesPR lens arr1)
+                  (replicatesPR lens arr2)
+                  (replicatesPR lens arr3)
+                  (replicatesPR lens arr4)
+
+
+  {-# INLINE_PDATA appendPR #-}
+  appendPR (PTuple4 arr11 arr12 arr13 arr14)
+           (PTuple4 arr21 arr22 arr23 arr24)
+        = PTuple4 (arr11 `appendPR` arr21)
+                  (arr12 `appendPR` arr22)
+                  (arr13 `appendPR` arr23) 
+                  (arr14 `appendPR` arr24) 
+
+
+  {-# INLINE_PDATA appendsPR #-}
+  appendsPR segdResult segd1 (PTuple4 arrs11 arrs12 arrs13 arrs14)
+                       segd2 (PTuple4 arrs21 arrs22 arrs23 arrs24)
+        = PTuple4 (appendsPR segdResult segd1 arrs11 segd2 arrs21)
+                  (appendsPR segdResult segd1 arrs12 segd2 arrs22)
+                  (appendsPR segdResult segd1 arrs13 segd2 arrs23)
+                  (appendsPR segdResult segd1 arrs14 segd2 arrs24)
+
+
+  -- Projections ---------------------------------
+  {-# INLINE_PDATA lengthPR #-}
+  lengthPR (PTuple4 arr1 _ _ _) 
+        = lengthPR arr1
+  
+  {-# INLINE_PDATA indexPR #-}
+  indexPR (PTuple4 arr1 arr2 arr3 arr4) ix
+        = ( indexPR arr1 ix
+          , indexPR arr2 ix
+          , indexPR arr3 ix
+          , indexPR arr4 ix)
+
+
+  {-# INLINE_PDATA indexsPR #-}
+  indexsPR (PTuple4s xs ys zs ds) srcs ixs
+        = PTuple4 (indexsPR xs srcs ixs)
+                  (indexsPR ys srcs ixs)
+                  (indexsPR zs srcs ixs)
+                  (indexsPR ds srcs ixs)
+
+  {-# INLINE_PDATA extractPR #-}
+  extractPR (PTuple4 arr1 arr2 arr3 arr4) start len
+        = PTuple4 (extractPR arr1 start len) 
+                  (extractPR arr2 start len)
+                  (extractPR arr3 start len)
+                  (extractPR arr4 start len)
+
+  {-# INLINE_PDATA extractsPR #-}
+  extractsPR (PTuple4s xs ys zs ds) ussegd
+        = PTuple4 (extractsPR xs ussegd)
+                  (extractsPR ys ussegd)
+                  (extractsPR zs ussegd)
+                  (extractsPR ds ussegd)
+
+
+  -- Pack and Combine ---------------------------
+  {-# INLINE_PDATA packByTagPR #-}
+  packByTagPR (PTuple4 arr1 arr2 arr3 arr4) tags tag
+        = PTuple4 (packByTagPR arr1 tags tag)
+                  (packByTagPR arr2 tags tag)
+                  (packByTagPR arr3 tags tag)
+                  (packByTagPR arr4 tags tag)
+
+
+  {-# INLINE_PDATA combine2PR #-}
+  combine2PR sel (PTuple4 xs1 ys1 zs1 ds1) (PTuple4 xs2 ys2 zs2 ds2)
+        = PTuple4 (combine2PR sel xs1 xs2)
+                  (combine2PR sel ys1 ys2)
+                  (combine2PR sel zs1 zs2)
+                  (combine2PR sel ds1 ds2)
+
+
+  -- Conversions --------------------------------
+  {-# INLINE_PDATA fromVectorPR #-}
+  fromVectorPR vec
+   = let (xs, ys, zs, ds)       = V.unzip4 vec
+     in  PTuple4  (fromVectorPR xs)
+                  (fromVectorPR ys)
+                  (fromVectorPR zs)
+                  (fromVectorPR ds)
+
+  {-# INLINE_PDATA toVectorPR #-}
+  toVectorPR (PTuple4 xs ys zs ds)
+        = V.zip4  (toVectorPR xs)
+                  (toVectorPR ys)
+                  (toVectorPR zs)
+                  (toVectorPR ds)
+
+
+  -- PData --------------------------------------
+  {-# INLINE_PDATA emptydPR #-}
+  emptydPR      
+        = PTuple4s emptydPR
+                   emptydPR
+                   emptydPR 
+                   emptydPR 
+
+  
+  {-# INLINE_PDATA singletondPR #-}
+  singletondPR (PTuple4 x y z d)
+        = PTuple4s (singletondPR x)
+                   (singletondPR y)
+                   (singletondPR z)
+                   (singletondPR d)
+
+
+  {-# INLINE_PDATA lengthdPR #-}
+  lengthdPR (PTuple4s xs _ _ _)
+        = lengthdPR xs
+   
+   
+  {-# INLINE_PDATA indexdPR #-}
+  indexdPR (PTuple4s xs ys zs ds) i
+        = PTuple4  (indexdPR xs i)
+                   (indexdPR ys i)
+                   (indexdPR zs i)
+                   (indexdPR ds i)
+
+   
+  {-# INLINE_PDATA appenddPR #-}
+  appenddPR (PTuple4s xs1 ys1 zs1 ds1) (PTuple4s xs2 ys2 zs2 ds2)
+        = PTuple4s (appenddPR xs1 xs2)
+                   (appenddPR ys1 ys2)
+                   (appenddPR zs1 zs2)
+                   (appenddPR ds1 ds2)
+  
+
+  {-# INLINE_PDATA fromVectordPR #-}
+  fromVectordPR vec
+   = let (xss, yss, zss, dss) = V.unzip4 $ V.map (\(PTuple4 xs ys zs ds) -> (xs, ys, zs, ds)) vec
+     in  PTuple4s  (fromVectordPR xss)
+                   (fromVectordPR yss)
+                   (fromVectordPR zss)
+                   (fromVectordPR dss)
+
+
+  {-# INLINE_PDATA toVectordPR #-}
+  toVectordPR (PTuple4s pdatas1 pdatas2 pdatas3 pdatas4)
+        = V.zipWith4 PTuple4
+                   (toVectordPR pdatas1)
+                   (toVectordPR pdatas2)
+                   (toVectordPR pdatas3)
+                   (toVectordPR pdatas4)
+
+
+-- PD Functions ---------------------------------------------------------------
+-- | O(1). Zip a pair of arrays into an array of pairs.
+zip4PD   :: PData a -> PData b -> PData c -> PData d -> PData (a, b, c, d)
+zip4PD   = PTuple4
+{-# INLINE_PA zip4PD #-}
+
+
+-- Show -----------------------------------------------------------------------
+deriving instance (Show (PData  a), Show (PData  b), Show (PData c), Show (PData d))
+        => Show (PData  (a, b, c, d))
+
+deriving instance (Show (PDatas a), Show (PDatas b), Show (PDatas c), Show (PDatas d))
+        => Show (PDatas (a, b, c, d))
+
+
+instance ( PR a, PR b, PR c, PR d, Show a, Show b, Show c, Show d
+         , PprVirtual (PData a), PprVirtual (PData b), PprVirtual (PData c), PprVirtual (PData d))
+        => PprVirtual (PData (a, b, c, d)) where
+ pprv   (PTuple4 xs ys zs ds)
+        = text $ show 
+        $ P.zip4 (V.toList $ toVectorPR xs) 
+                 (V.toList $ toVectorPR ys)
+                 (V.toList $ toVectorPR zs)
+                 (V.toList $ toVectorPR ds)
+
+                 
+                 
\ No newline at end of file
diff --git a/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple5.hs b/dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple5.hs
new file mode 100644 (file)
index 0000000..d0e9b37
--- /dev/null
@@ -0,0 +1,287 @@
+{-# OPTIONS_HADDOCK hide #-}
+#include "fusion-phases.h"
+
+-- | PR instance for tuples.
+module Data.Array.Parallel.PArray.PData.Tuple5
+        ( PData(..),    PDatas(..)
+        , zip5PD)
+where
+import Data.Array.Parallel.Pretty
+import Data.Array.Parallel.PArray.PData.Base
+import Data.Array.Parallel.PArray.PData.Nested
+import GHC.Exts
+import Prelude hiding (zip, unzip)
+import qualified Data.Vector                    as V
+import qualified Prelude                        as P
+import qualified Data.List                      as P
+
+-------------------------------------------------------------------------------
+data instance PData (a, b, c, d, e)
+        = PTuple5  (PData a) (PData b) (PData c) (PData d) (PData e)
+
+data instance PDatas (a, b, c, d, e)
+        = PTuple5s (PDatas a) (PDatas b) (PDatas c) (PDatas d) (PDatas e)
+
+
+-- PR -------------------------------------------------------------------------
+instance (PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) where
+
+  {-# INLINE_PDATA validPR #-}
+  validPR (PTuple5 xs ys zs ds es)
+        = validPR xs && validPR ys && validPR zs && validPR ds && validPR es
+
+
+  {-# INLINE_PDATA nfPR #-}
+  nfPR (PTuple5 arr1 arr2 arr3 arr4 arr5)
+        = nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` nfPR arr4 `seq` nfPR arr5 `seq` ()
+
+
+  {-# INLINE_PDATA similarPR #-}
+  similarPR (x1, y1, z1, d1, e1) (x2, y2, z2, d2, e2)
+        =  similarPR x1 x2
+        && similarPR y1 y2
+        && similarPR z1 z2
+        && similarPR d1 d2
+        && similarPR e1 e2
+
+
+  {-# INLINE_PDATA coversPR #-}
+  coversPR weak (PTuple5 arr1 arr2 arr3 arr4 arr5) ix
+        =  coversPR weak arr1 ix
+        && coversPR weak arr2 ix
+        && coversPR weak arr3 ix
+        && coversPR weak arr4 ix
+        && coversPR weak arr5 ix
+
+
+  {-# NOINLINE pprpPR #-}
+  pprpPR (x, y, z, d, e)
+        = text "Tuple5 "
+        <> vcat [ pprpPR x
+                , pprpPR y
+                , pprpPR z
+                , pprpPR d
+                , pprpPR e ]
+        
+
+  {-# NOINLINE pprpDataPR #-}
+  pprpDataPR (PTuple5 xs ys zs ds es)
+        = text "PTuple5 " 
+        <> vcat [ pprpDataPR xs
+                , pprpDataPR ys
+                , pprpDataPR zs
+                , pprpDataPR ds
+                , pprpDataPR es]
+
+
+  -- Constructors -------------------------------
+  {-# INLINE_PDATA emptyPR #-}
+  emptyPR
+        = PTuple5 emptyPR emptyPR emptyPR emptyPR emptyPR
+
+
+  {-# INLINE_PDATA replicatePR #-}
+  replicatePR len (x, y, z, d, e)
+        = PTuple5 (replicatePR len x)
+                  (replicatePR len y)
+                  (replicatePR len z)
+                  (replicatePR len d)
+                  (replicatePR len e)
+
+
+  {-# INLINE_PDATA replicatesPR #-}
+  replicatesPR lens (PTuple5 arr1 arr2 arr3 arr4 arr5)
+        = PTuple5 (replicatesPR lens arr1)
+                  (replicatesPR lens arr2)
+                  (replicatesPR lens arr3)
+                  (replicatesPR lens arr4)
+                  (replicatesPR lens arr5)
+
+
+  {-# INLINE_PDATA appendPR #-}
+  appendPR (PTuple5 arr11 arr12 arr13 arr14 arr15)
+           (PTuple5 arr21 arr22 arr23 arr24 arr25)
+        = PTuple5 (arr11 `appendPR` arr21)
+                  (arr12 `appendPR` arr22)
+                  (arr13 `appendPR` arr23) 
+                  (arr14 `appendPR` arr24) 
+                  (arr15 `appendPR` arr25) 
+
+
+  {-# INLINE_PDATA appendsPR #-}
+  appendsPR segdResult segd1 (PTuple5 arrs11 arrs12 arrs13 arrs14 arrs15)
+                       segd2 (PTuple5 arrs21 arrs22 arrs23 arrs24 arrs25)
+        = PTuple5 (appendsPR segdResult segd1 arrs11 segd2 arrs21)
+                  (appendsPR segdResult segd1 arrs12 segd2 arrs22)
+                  (appendsPR segdResult segd1 arrs13 segd2 arrs23)
+                  (appendsPR segdResult segd1 arrs14 segd2 arrs24)
+                  (appendsPR segdResult segd1 arrs15 segd2 arrs25)
+
+
+  -- Projections ---------------------------------
+  {-# INLINE_PDATA lengthPR #-}
+  lengthPR (PTuple5 arr1 _ _ _ _) 
+        = lengthPR arr1
+  
+  {-# INLINE_PDATA indexPR #-}
+  indexPR (PTuple5 arr1 arr2 arr3 arr4 arr5) ix
+        = ( indexPR arr1 ix
+          , indexPR arr2 ix
+          , indexPR arr3 ix
+          , indexPR arr4 ix
+          , indexPR arr5 ix)
+
+
+  {-# INLINE_PDATA indexsPR #-}
+  indexsPR (PTuple5s xs ys zs ds es) srcs ixs
+        = PTuple5 (indexsPR xs srcs ixs)
+                  (indexsPR ys srcs ixs)
+                  (indexsPR zs srcs ixs)
+                  (indexsPR ds srcs ixs)
+                  (indexsPR es srcs ixs)
+
+  {-# INLINE_PDATA extractPR #-}
+  extractPR (PTuple5 arr1 arr2 arr3 arr4 arr5) start len
+        = PTuple5 (extractPR arr1 start len) 
+                  (extractPR arr2 start len)
+                  (extractPR arr3 start len)
+                  (extractPR arr4 start len)
+                  (extractPR arr5 start len)
+
+  {-# INLINE_PDATA extractsPR #-}
+  extractsPR (PTuple5s xs ys zs ds es) ussegd
+        = PTuple5 (extractsPR xs ussegd)
+                  (extractsPR ys ussegd)
+                  (extractsPR zs ussegd)
+                  (extractsPR ds ussegd)
+                  (extractsPR es ussegd)
+
+
+  -- Pack and Combine ---------------------------
+  {-# INLINE_PDATA packByTagPR #-}
+  packByTagPR (PTuple5 arr1 arr2 arr3 arr4 arr5) tags tag
+        = PTuple5 (packByTagPR arr1 tags tag)
+                  (packByTagPR arr2 tags tag)
+                  (packByTagPR arr3 tags tag)
+                  (packByTagPR arr4 tags tag)
+                  (packByTagPR arr5 tags tag)
+
+
+  {-# INLINE_PDATA combine2PR #-}
+  combine2PR sel (PTuple5 xs1 ys1 zs1 ds1 es1) (PTuple5 xs2 ys2 zs2 ds2 es2)
+        = PTuple5 (combine2PR sel xs1 xs2)
+                  (combine2PR sel ys1 ys2)
+                  (combine2PR sel zs1 zs2)
+                  (combine2PR sel ds1 ds2)
+                  (combine2PR sel es1 es2)
+
+
+  -- Conversions --------------------------------
+  {-# INLINE_PDATA fromVectorPR #-}
+  fromVectorPR vec
+   = let (xs, ys, zs, ds, es)       = V.unzip5 vec
+     in  PTuple5  (fromVectorPR xs)
+                  (fromVectorPR ys)
+                  (fromVectorPR zs)
+                  (fromVectorPR ds)
+                  (fromVectorPR es)
+
+  {-# INLINE_PDATA toVectorPR #-}
+  toVectorPR (PTuple5 xs ys zs ds es)
+        = V.zip5  (toVectorPR xs)
+                  (toVectorPR ys)
+                  (toVectorPR zs)
+                  (toVectorPR ds)
+                  (toVectorPR es)
+
+
+  -- PData --------------------------------------
+  {-# INLINE_PDATA emptydPR #-}
+  emptydPR      
+        = PTuple5s emptydPR
+                   emptydPR
+                   emptydPR 
+                   emptydPR 
+                   emptydPR 
+
+  
+  {-# INLINE_PDATA singletondPR #-}
+  singletondPR (PTuple5 x y z d e)
+        = PTuple5s (singletondPR x)
+                   (singletondPR y)
+                   (singletondPR z)
+                   (singletondPR d)
+                   (singletondPR e)
+
+
+  {-# INLINE_PDATA lengthdPR #-}
+  lengthdPR (PTuple5s xs _ _ _ _)
+        = lengthdPR xs
+   
+   
+  {-# INLINE_PDATA indexdPR #-}
+  indexdPR (PTuple5s xs ys zs ds es) i
+        = PTuple5  (indexdPR xs i)
+                   (indexdPR ys i)
+                   (indexdPR zs i)
+                   (indexdPR ds i)
+                   (indexdPR es i)
+
+   
+  {-# INLINE_PDATA appenddPR #-}
+  appenddPR (PTuple5s xs1 ys1 zs1 ds1 es1) (PTuple5s xs2 ys2 zs2 ds2 es2)
+        = PTuple5s (appenddPR xs1 xs2)
+                   (appenddPR ys1 ys2)
+                   (appenddPR zs1 zs2)
+                   (appenddPR ds1 ds2)
+                   (appenddPR es1 es2)
+  
+
+  {-# INLINE_PDATA fromVectordPR #-}
+  fromVectordPR vec
+   = let (xss, yss, zss, dss, ess) = V.unzip5 $ V.map (\(PTuple5 xs ys zs ds es) -> (xs, ys, zs, ds, es)) vec
+     in  PTuple5s  (fromVectordPR xss)
+                   (fromVectordPR yss)
+                   (fromVectordPR zss)
+                   (fromVectordPR dss)
+                   (fromVectordPR ess)
+
+
+  {-# INLINE_PDATA toVectordPR #-}
+  toVectordPR (PTuple5s pdatas1 pdatas2 pdatas3 pdatas4 pdatas5)
+        = V.zipWith5 PTuple5
+                   (toVectordPR pdatas1)
+                   (toVectordPR pdatas2)
+                   (toVectordPR pdatas3)
+                   (toVectordPR pdatas4)
+                   (toVectordPR pdatas5)
+
+
+-- PD Functions ---------------------------------------------------------------
+-- | O(1). Zip a pair of arrays into an array of pairs.
+zip5PD   :: PData a -> PData b -> PData c -> PData d -> PData e -> PData (a, b, c, d, e)
+zip5PD   = PTuple5
+{-# INLINE_PA zip5PD #-}
+
+
+-- Show -----------------------------------------------------------------------
+deriving instance (Show (PData  a), Show (PData  b), Show (PData c), Show (PData d), Show (PData e))
+        => Show (PData  (a, b, c, d, e))
+
+deriving instance (Show (PDatas a), Show (PDatas b), Show (PDatas c), Show (PDatas d), Show (PDatas e))
+        => Show (PDatas (a, b, c, d, e))
+
+
+instance ( PR a, PR b, PR c, PR d, PR e, Show a, Show b, Show c, Show d, Show e
+         , PprVirtual (PData a), PprVirtual (PData b), PprVirtual (PData c), PprVirtual (PData d), PprVirtual (PData e))
+        => PprVirtual (PData (a, b, c, d, e)) where
+ pprv   (PTuple5 xs ys zs ds es)
+        = text $ show 
+        $ P.zip5 (V.toList $ toVectorPR xs) 
+                 (V.toList $ toVectorPR ys)
+                 (V.toList $ toVectorPR zs)
+                 (V.toList $ toVectorPR ds)
+                 (V.toList $ toVectorPR es)
+
+                 
+                 
\ No newline at end of file
index 09d9bdf..f2c85cc 100644 (file)
@@ -11,16 +11,17 @@ import Data.Array.Parallel.PArray.Types
 import Data.Array.Parallel.PArray.PRepr.Base
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.PArray.PData.Tuple2
+import Data.Array.Parallel.PArray.PData.Tuple3
+import Data.Array.Parallel.PArray.PData.Tuple4
+import Data.Array.Parallel.PArray.PData.Tuple5
 import Data.Array.Parallel.PArray.PData.Wrap
 
 
--------------------------------------------------------------------------------
-type instance PRepr (a,b)
+-- Tuple2 --------------------------------------------------------------------
+type instance PRepr (a, b)
         = (Wrap a, Wrap b)
 
-
--- PA -------------------------------------------------------------------------
-instance (PA a, PA b) => PA (a,b) where
+instance (PA a, PA b) => PA (a, b) where
   {-# INLINE_PA toPRepr #-}
   toPRepr (a, b)
         = (Wrap a, Wrap b)
@@ -57,3 +58,93 @@ ziplPA xs ys
                   (fromArrPReprs xs') (fromArrPReprs ys'))
 
 
+-- Tuple3 --------------------------------------------------------------------
+type instance PRepr (a, b, c)
+        = (Wrap a, Wrap b, Wrap c)
+
+instance (PA a, PA b, PA c) => PA (a, b, c) where
+  {-# INLINE_PA toPRepr #-}
+  toPRepr (a, b, c)
+        = (Wrap a, Wrap b, Wrap c)
+
+  {-# INLINE_PA fromPRepr #-}
+  fromPRepr (Wrap a, Wrap b, Wrap c)
+        = (a, b, c)
+
+  {-# INLINE_PA toArrPRepr #-}
+  toArrPRepr (PTuple3 as bs cs)
+        = PTuple3 (PWrap as) (PWrap bs) (PWrap cs)
+
+  {-# INLINE_PA fromArrPRepr #-}
+  fromArrPRepr (PTuple3 (PWrap as) (PWrap bs) (PWrap cs))
+        = PTuple3 as bs cs
+
+  {-# INLINE_PA toArrPReprs #-}
+  toArrPReprs (PTuple3s as bs cs)
+        = PTuple3s (PWraps as) (PWraps bs) (PWraps cs)
+
+  {-# INLINE_PA fromArrPReprs #-}
+  fromArrPReprs (PTuple3s (PWraps as) (PWraps bs) (PWraps cs))
+        = PTuple3s as bs cs
+
+
+-- Tuple4 --------------------------------------------------------------------
+type instance PRepr (a, b, c, d)
+        = (Wrap a, Wrap b, Wrap c, Wrap d)
+
+instance (PA a, PA b, PA c, PA d) => PA (a, b, c, d) where
+  {-# INLINE_PA toPRepr #-}
+  toPRepr (a, b, c, d)
+        = (Wrap a, Wrap b, Wrap c, Wrap d)
+
+  {-# INLINE_PA fromPRepr #-}
+  fromPRepr (Wrap a, Wrap b, Wrap c, Wrap d)
+        = (a, b, c, d)
+
+  {-# INLINE_PA toArrPRepr #-}
+  toArrPRepr (PTuple4 as bs cs ds)
+        = PTuple4 (PWrap as) (PWrap bs) (PWrap cs) (PWrap ds)
+
+  {-# INLINE_PA fromArrPRepr #-}
+  fromArrPRepr (PTuple4 (PWrap as) (PWrap bs) (PWrap cs) (PWrap ds))
+        = PTuple4 as bs cs ds
+
+  {-# INLINE_PA toArrPReprs #-}
+  toArrPReprs (PTuple4s as bs cs ds)
+        = PTuple4s (PWraps as) (PWraps bs) (PWraps cs) (PWraps ds)
+
+  {-# INLINE_PA fromArrPReprs #-}
+  fromArrPReprs (PTuple4s (PWraps as) (PWraps bs) (PWraps cs) (PWraps ds))
+        = PTuple4s as bs cs ds
+
+
+-- Tuple4 --------------------------------------------------------------------
+type instance PRepr (a, b, c, d, e)
+        = (Wrap a, Wrap b, Wrap c, Wrap d, Wrap e)
+
+instance (PA a, PA b, PA c, PA d, PA e) => PA (a, b, c, d, e) where
+  {-# INLINE_PA toPRepr #-}
+  toPRepr (a, b, c, d, e)
+        = (Wrap a, Wrap b, Wrap c, Wrap d, Wrap e)
+
+  {-# INLINE_PA fromPRepr #-}
+  fromPRepr (Wrap a, Wrap b, Wrap c, Wrap d, Wrap e)
+        = (a, b, c, d, e)
+
+  {-# INLINE_PA toArrPRepr #-}
+  toArrPRepr (PTuple5 as bs cs ds es)
+        = PTuple5 (PWrap as) (PWrap bs) (PWrap cs) (PWrap ds) (PWrap es)
+
+  {-# INLINE_PA fromArrPRepr #-}
+  fromArrPRepr (PTuple5 (PWrap as) (PWrap bs) (PWrap cs) (PWrap ds) (PWrap es))
+        = PTuple5 as bs cs ds es
+
+  {-# INLINE_PA toArrPReprs #-}
+  toArrPReprs (PTuple5s as bs cs ds es)
+        = PTuple5s (PWraps as) (PWraps bs) (PWraps cs) (PWraps ds) (PWraps es)
+
+  {-# INLINE_PA fromArrPReprs #-}
+  fromArrPReprs (PTuple5s (PWraps as) (PWraps bs) (PWraps cs) (PWraps ds) (PWraps es))
+        = PTuple5s as bs cs ds es
+
+
index 80c2cdc..c207584 100644 (file)
@@ -1,15 +1,30 @@
 module Data.Array.Parallel.Prelude.Tuple (
-  tup2, tup3
+  tup2, tup3, tup4, tup5
 ) where
   
 import Data.Array.Parallel.Lifted.Closure
 import Data.Array.Parallel.PArray.PRepr
 import qualified Data.Array.Parallel.PArray     as PA
 
-tup2 :: (PA a, PA b) => a :-> b :-> (a, b)
+tup2    :: (PA a, PA b)
+        => a :-> b :-> (a, b)
+tup2    = closure2' (,) PA.zip
 {-# INLINE tup2 #-}
-tup2 = closure2' (,) PA.zip
 
-tup3 :: (PA a, PA b, PA c) => a :-> b :-> c :-> (a, b, c)
+
+tup3    :: (PA a, PA b, PA c)
+        => a :-> b :-> c :-> (a, b, c)
+tup3    = closure3' (,,) PA.zip3
 {-# INLINE tup3 #-}
-tup3 = closure3 (,,) (error "tup3") -- zip3PA#
+
+
+tup4    :: (PA a, PA b, PA c, PA d)
+        => a :-> b :-> c :-> d :-> (a, b, c, d)
+tup4    = closure4' (,,,) PA.zip4
+{-# INLINE tup4 #-}
+
+
+tup5    :: (PA a, PA b, PA c, PA d)
+        =>  a :-> b :-> c :-> d :-> e :-> (a, b, c, d, e)
+tup5    = closure5' (,,,,) PA.zip5
+{-# INLINE tup5 #-}
index 0a0c7c1..97c3b77 100644 (file)
@@ -46,8 +46,8 @@ module Data.Array.Parallel.Prim
         , packByTagPA_Int#,     packByTagPA_Double#
         , combine2PA_Int#,      combine2PA_Double#
 
-        -- Tuple functions
-        , tup2, tup3)
+        -- Tuple constructors
+        , tup2, tup3, tup4, tup5)
 where
 import Data.Array.Parallel.PArray.PData.Base   
         (PArray(..), PData, PDatas, PR(..))
@@ -73,7 +73,7 @@ import Data.Array.Parallel.Lifted.Closure
         ( (:->)(..))
 
 import Data.Array.Parallel.Prelude.Tuple
-        ( tup2, tup3)
+        ( tup2, tup3, tup4, tup5)
 
 import Data.Array.Parallel.Base                         (Tag, intToTag)
 import qualified Data.Array.Parallel.Unlifted           as U
index b66ade7..509552d 100644 (file)
@@ -23,6 +23,9 @@ Library
         Data.Array.Parallel.PArray.PData.Nested
         Data.Array.Parallel.PArray.PData.Sum2
         Data.Array.Parallel.PArray.PData.Tuple2
+        Data.Array.Parallel.PArray.PData.Tuple3
+        Data.Array.Parallel.PArray.PData.Tuple4
+        Data.Array.Parallel.PArray.PData.Tuple5
         Data.Array.Parallel.PArray.PData.Unit
         Data.Array.Parallel.PArray.PData.Void
         Data.Array.Parallel.PArray.PData.Wrap