#include "fusion-phases.h"
module Data.Array.Parallel.PArray.PRepr (
PRepr,
PA(..),
emptyPD,
replicatePD,
replicatelPD,
repeatPD,
indexPD,
extractPD,
bpermutePD,
appPD,
applPD,
packByTagPD,
combine2PD,
updatePD,
fromListPD,
nfPD
)
where
import Data.Array.Parallel.PArray.PData
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
emptyPD :: PA a => T_emptyPR a
emptyPD
= fromArrPRepr emptyPR
replicatePD :: PA a => T_replicatePR a
replicatePD n# x
= fromArrPRepr
. replicatePR n#
$ toPRepr x
replicatelPD :: PA a => T_replicatelPR a
replicatelPD segd xs
= fromArrPRepr
. replicatelPR segd
$ toArrPRepr xs
repeatPD :: PA a => T_repeatPR a
repeatPD n# len# xs
= fromArrPRepr
. repeatPR n# len#
$ toArrPRepr xs
indexPD :: PA a => T_indexPR a
indexPD xs i#
= fromPRepr
$ indexPR (toArrPRepr xs) i#
extractPD :: PA a => T_extractPR a
extractPD xs i# m#
= fromArrPRepr
$ extractPR (toArrPRepr xs) i# m#
bpermutePD :: PA a => T_bpermutePR a
bpermutePD xs n# is
= fromArrPRepr
$ bpermutePR (toArrPRepr xs) n# is
appPD :: PA a => T_appPR a
appPD xs ys
= fromArrPRepr
$ appPR (toArrPRepr xs) (toArrPRepr ys)
applPD :: PA a => T_applPR a
applPD segd is xs js ys
= fromArrPRepr
$ applPR segd is (toArrPRepr xs) js (toArrPRepr ys)
packByTagPD :: PA a => T_packByTagPR a
packByTagPD xs n# tags t#
= fromArrPRepr
$ packByTagPR (toArrPRepr xs) n# tags t#
combine2PD :: PA a => T_combine2PR a
combine2PD n# sel as bs
= fromArrPRepr
$ combine2PR n# sel (toArrPRepr as) (toArrPRepr bs)
updatePD :: PA a => T_updatePR a
updatePD xs is ys
= fromArrPRepr
$ updatePR (toArrPRepr xs) is (toArrPRepr ys)
fromListPD :: PA a => T_fromListPR a
fromListPD n# xs
= fromArrPRepr
$ fromListPR n# (map toPRepr xs)
nfPD :: PA a => T_nfPR a
nfPD xs = nfPR (toArrPRepr xs)