#include "fusion-phases.h"
module Data.Array.Parallel.PArray.PRepr.Base
( PRepr
, PA (..)
, toNestedArrPRepr
, validPA
, nfPA
, similarPA
, coversPA
, pprpPA
, pprpDataPA
, emptyPA
, replicatePA, replicatesPA
, appendPA, appendsPA
, lengthPA
, indexPA, indexsPA, indexvsPA
, bpermutePA
, extractPA, extractssPA, extractvsPA
, packByTagPA
, combine2PA
, fromVectorPA, toVectorPA
, emptydPA
, singletondPA
, lengthdPA
, indexdPA
, appenddPA
, fromVectordPA, toVectordPA)
where
import Data.Array.Parallel.Pretty
import Data.Array.Parallel.PArray.PData.Base
import Data.Array.Parallel.PArray.PData.Nested
import Data.Array.Parallel.Base (Tag)
import Data.Vector (Vector)
import qualified Data.Array.Parallel.Unlifted as U
import qualified Data.Vector as V
type family PRepr a
class PR (PRepr a) => PA a where
toPRepr :: a -> PRepr a
fromPRepr :: PRepr a -> a
toArrPRepr :: PData a -> PData (PRepr a)
fromArrPRepr :: PData (PRepr a) -> PData a
toArrPReprs :: PDatas a -> PDatas (PRepr a)
fromArrPReprs :: PDatas (PRepr a) -> PDatas a
toNestedArrPRepr
:: PA a
=> PData (PArray a)
-> PData (PArray (PRepr a))
toNestedArrPRepr (PNested vsegd pdatas segd flat)
= PNested vsegd (toArrPReprs pdatas) segd (toArrPRepr flat)
validPA :: PA a => PData a -> Bool
validPA arr
= validPR (toArrPRepr arr)
nfPA :: PA a => PData a -> ()
nfPA arr
= nfPR
$ toArrPRepr arr
similarPA :: PA a => a -> a -> Bool
similarPA x y
= similarPR (toPRepr x) (toPRepr y)
coversPA :: PA a => Bool -> PData a -> Int -> Bool
coversPA weak pdata ix
= coversPR weak (toArrPRepr pdata) ix
pprpPA :: PA a => a -> Doc
pprpPA x
= pprpPR (toPRepr x)
pprpDataPA :: PA a => PData a -> Doc
pprpDataPA x
= pprpDataPR (toArrPRepr x)
emptyPA :: PA a => PData a
emptyPA
= fromArrPRepr emptyPR
replicatePA :: PA a => Int -> a -> PData a
replicatePA n x
= fromArrPRepr
$ replicatePR n $ toPRepr x
replicatesPA :: PA a => U.Segd -> PData a -> PData a
replicatesPA segd xs
= fromArrPRepr
$ replicatesPR segd (toArrPRepr xs)
appendPA :: PA a => PData a -> PData a -> PData a
appendPA xs ys
= fromArrPRepr
$ appendPR (toArrPRepr xs) (toArrPRepr ys)
appendsPA :: PA a => U.Segd -> U.Segd -> PData a -> U.Segd
-> PData a -> PData a
appendsPA segdResult segd1 xs segd2 ys
= fromArrPRepr
$ appendsPR segdResult segd1 (toArrPRepr xs) segd2 (toArrPRepr ys)
lengthPA :: PA a => PData a -> Int
lengthPA xs
= lengthPR (toArrPRepr xs)
indexPA :: PA a => PData a -> Int -> a
indexPA xs i
= fromPRepr
$ indexPR (toArrPRepr xs) i
indexsPA :: PA a => PDatas a -> U.Array (Int, Int) -> PData a
indexsPA pdatas srcixs
= fromArrPRepr
$ indexsPR (toArrPReprs pdatas) srcixs
indexvsPA :: PA a => PDatas a -> U.VSegd -> U.Array (Int, Int) -> PData a
indexvsPA pdatas vsegd srcixs
= fromArrPRepr
$ indexvsPR (toArrPReprs pdatas) vsegd srcixs
bpermutePA :: PA a => PData a -> U.Array Int -> PData a
bpermutePA xs ixs
= fromArrPRepr
$ bpermutePR (toArrPRepr xs) ixs
extractPA :: PA a => PData a -> Int -> Int -> PData a
extractPA xs start len
= fromArrPRepr
$ extractPR (toArrPRepr xs) start len
extractssPA :: PA a => PDatas a -> U.SSegd -> PData a
extractssPA xss segd
= fromArrPRepr
$ extractssPR (toArrPReprs xss) segd
extractvsPA :: PA a => PDatas a -> U.VSegd -> PData a
extractvsPA xss segd
= fromArrPRepr
$ extractvsPR (toArrPReprs xss) segd
packByTagPA :: PA a => PData a -> U.Array Tag -> Tag -> PData a
packByTagPA xs tags tag
= fromArrPRepr
$ packByTagPR (toArrPRepr xs) tags tag
combine2PA :: PA a => U.Sel2 -> PData a -> PData a -> PData a
combine2PA sel xs ys
= fromArrPRepr
$ combine2PR sel (toArrPRepr xs) (toArrPRepr ys)
fromVectorPA :: PA a => Vector a -> PData a
fromVectorPA vec
= fromArrPRepr
$ fromVectorPR (V.map toPRepr vec)
toVectorPA :: PA a => PData a -> Vector a
toVectorPA pdata
= V.map fromPRepr
$ toVectorPR (toArrPRepr pdata)
emptydPA :: PA a => PDatas a
emptydPA
= fromArrPReprs
$ emptydPR
singletondPA :: PA a => PData a -> PDatas a
singletondPA pdata
= fromArrPReprs
$ singletondPR (toArrPRepr pdata)
lengthdPA :: PA a => PDatas a -> Int
lengthdPA pdatas
= lengthdPR (toArrPReprs pdatas)
indexdPA :: PA a => PDatas a -> Int -> PData a
indexdPA pdatas ix
= fromArrPRepr
$ indexdPR (toArrPReprs pdatas) ix
appenddPA :: PA a => PDatas a -> PDatas a -> PDatas a
appenddPA xs ys
= fromArrPReprs
$ appenddPR (toArrPReprs xs) (toArrPReprs ys)
fromVectordPA :: PA a => V.Vector (PData a) -> PDatas a
fromVectordPA vec
= fromArrPReprs
$ fromVectordPR (V.map toArrPRepr vec)
toVectordPA :: PA a => PDatas a -> V.Vector (PData a)
toVectordPA pdatas
= V.map fromArrPRepr
$ toVectordPR (toArrPReprs pdatas)