#include "fusion-phases.h"
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)
instance (PR a, PR b, PR c, PR d) => PR (a, b, c, d) where
validPR (PTuple4 xs ys zs ds)
= validPR xs && validPR ys && validPR zs && validPR ds
nfPR (PTuple4 arr1 arr2 arr3 arr4)
= nfPR arr1 `seq` nfPR arr2 `seq` nfPR arr3 `seq` nfPR arr4 `seq` ()
similarPR (x1, y1, z1, d1) (x2, y2, z2, d2)
= similarPR x1 x2
&& similarPR y1 y2
&& similarPR z1 z2
&& similarPR d1 d2
coversPR weak (PTuple4 arr1 arr2 arr3 arr4) ix
= coversPR weak arr1 ix
&& coversPR weak arr2 ix
&& coversPR weak arr3 ix
&& coversPR weak arr4 ix
pprpPR (x, y, z, d)
= text "Tuple4 "
<> vcat [ pprpPR x
, pprpPR y
, pprpPR z
, pprpPR d ]
pprpDataPR (PTuple4 xs ys zs ds)
= text "PTuple4 "
<> vcat [ pprpDataPR xs
, pprpDataPR ys
, pprpDataPR zs
, pprpDataPR ds]
emptyPR
= PTuple4 emptyPR emptyPR emptyPR emptyPR
replicatePR len (x, y, z, d)
= PTuple4 (replicatePR len x)
(replicatePR len y)
(replicatePR len z)
(replicatePR len d)
replicatesPR lens (PTuple4 arr1 arr2 arr3 arr4)
= PTuple4 (replicatesPR lens arr1)
(replicatesPR lens arr2)
(replicatesPR lens arr3)
(replicatesPR lens arr4)
appendPR (PTuple4 arr11 arr12 arr13 arr14)
(PTuple4 arr21 arr22 arr23 arr24)
= PTuple4 (arr11 `appendPR` arr21)
(arr12 `appendPR` arr22)
(arr13 `appendPR` arr23)
(arr14 `appendPR` arr24)
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)
lengthPR (PTuple4 arr1 _ _ _)
= lengthPR arr1
indexPR (PTuple4 arr1 arr2 arr3 arr4) ix
= ( indexPR arr1 ix
, indexPR arr2 ix
, indexPR arr3 ix
, indexPR arr4 ix)
indexsPR (PTuple4s xs ys zs ds) srcixs
= PTuple4 (indexsPR xs srcixs)
(indexsPR ys srcixs)
(indexsPR zs srcixs)
(indexsPR ds srcixs)
indexvsPR (PTuple4s xs ys zs ds) vsegd srcixs
= PTuple4 (indexvsPR xs vsegd srcixs)
(indexvsPR ys vsegd srcixs)
(indexvsPR zs vsegd srcixs)
(indexvsPR ds vsegd srcixs)
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)
extractssPR (PTuple4s xs ys zs ds) ussegd
= PTuple4 (extractssPR xs ussegd)
(extractssPR ys ussegd)
(extractssPR zs ussegd)
(extractssPR ds ussegd)
extractvsPR (PTuple4s xs ys zs ds) uvsegd
= PTuple4 (extractvsPR xs uvsegd)
(extractvsPR ys uvsegd)
(extractvsPR zs uvsegd)
(extractvsPR ds uvsegd)
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)
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)
fromVectorPR vec
= let (xs, ys, zs, ds) = V.unzip4 vec
in PTuple4 (fromVectorPR xs)
(fromVectorPR ys)
(fromVectorPR zs)
(fromVectorPR ds)
toVectorPR (PTuple4 xs ys zs ds)
= V.zip4 (toVectorPR xs)
(toVectorPR ys)
(toVectorPR zs)
(toVectorPR ds)
emptydPR
= PTuple4s emptydPR
emptydPR
emptydPR
emptydPR
singletondPR (PTuple4 x y z d)
= PTuple4s (singletondPR x)
(singletondPR y)
(singletondPR z)
(singletondPR d)
lengthdPR (PTuple4s xs _ _ _)
= lengthdPR xs
indexdPR (PTuple4s xs ys zs ds) i
= PTuple4 (indexdPR xs i)
(indexdPR ys i)
(indexdPR zs i)
(indexdPR ds i)
appenddPR (PTuple4s xs1 ys1 zs1 ds1) (PTuple4s xs2 ys2 zs2 ds2)
= PTuple4s (appenddPR xs1 xs2)
(appenddPR ys1 ys2)
(appenddPR zs1 zs2)
(appenddPR ds1 ds2)
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)
toVectordPR (PTuple4s pdatas1 pdatas2 pdatas3 pdatas4)
= V.zipWith4 PTuple4
(toVectordPR pdatas1)
(toVectordPR pdatas2)
(toVectordPR pdatas3)
(toVectordPR pdatas4)
zip4PD :: PData a -> PData b -> PData c -> PData d -> PData (a, b, c, d)
zip4PD = PTuple4
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)