module Data.Array.Parallel.PArray.Scalar (
Scalar(..),
emptyPRScalar,
replicatePRScalar,
replicatelPRScalar,
repeatPRScalar,
indexPRScalar,
extractPRScalar,
bpermutePRScalar,
appPRScalar,
applPRScalar,
packByTagPRScalar,
combine2PRScalar,
updatePRScalar,
fromListPRScalar,
nfPRScalar
)
where
import Data.Array.Parallel.PArray.PData
import Data.Array.Parallel.Base
import Data.Array.Parallel.Base.DTrace
import qualified Data.Array.Parallel.Unlifted as U
import GHC.Exts (Int(..))
class U.Elt a => Scalar a where
fromScalarPData :: PData a -> U.Array a
toScalarPData :: U.Array a -> PData a
emptyPRScalar :: Scalar a => T_emptyPR a
emptyPRScalar
= toScalarPData U.empty
replicatePRScalar :: Scalar a => T_replicatePR a
replicatePRScalar n# x
= traceF "replicatePRScalar"
$ toScalarPData (U.replicate (I# n#) x)
replicatelPRScalar :: Scalar a => T_replicatelPR a
replicatelPRScalar segd xs
= traceF "replicatelPRScalar"
$ toScalarPData
$ U.replicate_s segd
$ fromScalarPData xs
repeatPRScalar :: Scalar a => T_repeatPR a
repeatPRScalar n# len# xs
= traceF "repeatPRScalar"
$ toScalarPData
$ U.repeat (I# n#) (I# len#)
$ fromScalarPData xs
indexPRScalar :: Scalar a => T_indexPR a
indexPRScalar xs i#
= U.index "indexPRScalar" (fromScalarPData xs) (I# i#)
extractPRScalar :: Scalar a => T_extractPR a
extractPRScalar xs i# n#
= traceF "extractPRScalar"
$ toScalarPData
$ U.extract (fromScalarPData xs) (I# i#) (I# n#)
bpermutePRScalar :: Scalar a => T_bpermutePR a
bpermutePRScalar xs _ is
= traceF "bpermutePRScalar"
$ toScalarPData
$ U.bpermute (fromScalarPData xs) is
appPRScalar :: Scalar a => T_appPR a
appPRScalar xs ys
= traceF "appPRScalar"
$ toScalarPData
$ fromScalarPData xs U.+:+ fromScalarPData ys
applPRScalar :: Scalar a => T_applPR a
applPRScalar segd xsegd xs ysegd ys
= traceF "applPRScalar"
$ toScalarPData
$ U.append_s segd xsegd (fromScalarPData xs)
ysegd (fromScalarPData ys)
packByTagPRScalar :: Scalar a => T_packByTagPR a
packByTagPRScalar xs _ tags t#
= traceF "packByTagPRScalar"
$ toScalarPData
$ U.packByTag (fromScalarPData xs)
tags
(intToTag (I# t#))
combine2PRScalar :: Scalar a => T_combine2PR a
combine2PRScalar _ sel xs ys
= traceF "combine2PRScalar"
$ toScalarPData
$ U.combine2 (U.tagsSel2 sel)
(U.repSel2 sel)
(fromScalarPData xs)
(fromScalarPData ys)
updatePRScalar :: Scalar a => T_updatePR a
updatePRScalar xs is ys
= traceF "updatePRScalar"
$ toScalarPData
$ U.update (fromScalarPData xs)
(U.zip is (fromScalarPData ys))
fromListPRScalar :: Scalar a => T_fromListPR a
fromListPRScalar _ xs
= toScalarPData (U.fromList xs)
nfPRScalar :: Scalar a => T_nfPR a
nfPRScalar xs
= fromScalarPData xs `seq` ()