#include "fusion-phases.h"
module Data.Array.Parallel.Lifted.Unboxed (
Segd, elementsSegd#, mkSegd#,
Sel2, elementsSel2_0#, elementsSel2_1#, replicateSel2#, pickSel2#, tagsSel2,
PArray_Int#,
lengthPA_Int#, emptyPA_Int#,
replicatePA_Int#, replicatelPA_Int#, repeatPA_Int#,
indexPA_Int#, extractPA_Int#, bpermutePA_Int#,
appPA_Int#, applPA_Int#,
packPA_Int#, pack'PA_Int#, combine2PA_Int#, combine2'PA_Int#,
fromListPA_Int#,
upToPA_Int#, enumFromToPA_Int#, enumFromThenToPA_Int#,
enumFromStepLenPA_Int#,
selectPA_Int#, selectorToIndices2PA#,
sumPA_Int#, sumPAs_Int#,
unsafe_mapPA_Int#, unsafe_zipWithPA_Int#, unsafe_foldPA_Int#,
unsafe_scanPA_Int#,
PArray_Word8#,
lengthPA_Word8#, emptyPA_Word8#,
replicatePA_Word8#, replicatelPA_Word8#, repeatPA_Word8#,
indexPA_Word8#, extractPA_Word8#, bpermutePA_Word8#,
appPA_Word8#, applPA_Word8#,
packPA_Word8#, pack'PA_Word8#, combine2PA_Word8#, combine2'PA_Word8#,
fromListPA_Word8#,
unsafe_zipWithPA_Word8#, unsafe_foldPA_Word8#, unsafe_fold1PA_Word8#,
unsafe_foldPAs_Word8#,
PArray_Double#,
lengthPA_Double#, emptyPA_Double#,
replicatePA_Double#, replicatelPA_Double#, repeatPA_Double#,
indexPA_Double#, extractPA_Double#, bpermutePA_Double#,
appPA_Double#, applPA_Double#,
packPA_Double#, pack'PA_Double#, combine2PA_Double#, combine2'PA_Double#,
fromListPA_Double#,
unsafe_zipWithPA_Double#, unsafe_foldPA_Double#, unsafe_fold1PA_Double#,
unsafe_foldPAs_Double#,
PArray_Bool#,
lengthPA_Bool#, replicatelPA_Bool#,
packPA_Bool#, truesPA_Bool#, truesPAs_Bool#,
fromBoolPA#, toBoolPA#
) where
import qualified Data.Array.Parallel.Unlifted as U
import Data.Array.Parallel.Base (
Tag, fromBool, toBool, intToTag, tagToInt )
import GHC.Exts ( Int#, Int(..), Word#,
Double#, Double(..) )
import GHC.Word ( Word8(..) )
type Segd = U.Segd
type Sel2 = U.Sel2
elementsSegd# :: Segd -> Int#
elementsSegd# segd = case U.elementsSegd segd of { I# n# -> n# }
mkSegd# :: U.Array Int -> U.Array Int -> Int# -> Segd
mkSegd# ns is n# = U.mkSegd ns is (I# n#)
replicateSel2# :: Int# -> Int# -> Sel2
replicateSel2# n# tag# = U.mkSel2 (U.replicate n (intToTag tag))
(U.enumFromStepLen 0 1 n)
(if tag == 0 then n else 0)
(if tag == 0 then 0 else n)
(U.mkSelRep2 (U.replicate n (intToTag tag)))
where
n = I# n#
tag = I# tag#
pickSel2# :: Sel2 -> Int# -> U.Array Bool
pickSel2# sel tag# = U.pick (U.tagsSel2 sel) (intToTag (I# tag#))
tagsSel2 :: Sel2 -> U.Array Tag
tagsSel2 = U.tagsSel2
elementsSel2_0# :: Sel2 -> Int#
elementsSel2_0# sel = case U.elementsSel2_0 sel of { I# n# -> n# }
elementsSel2_1# :: Sel2 -> Int#
elementsSel2_1# sel = case U.elementsSel2_1 sel of { I# n# -> n# }
type PArray_Int# = U.Array Int
lengthPA_Int# :: PArray_Int# -> Int#
lengthPA_Int# arr = case U.length arr of { I# n# -> n# }
emptyPA_Int# :: PArray_Int#
emptyPA_Int# = U.empty
replicatePA_Int# :: Int# -> Int# -> PArray_Int#
replicatePA_Int# n# i# = U.replicate (I# n#) (I# i#)
replicatelPA_Int# :: Segd -> PArray_Int# -> PArray_Int#
replicatelPA_Int# segd is = U.replicate_s segd is
repeatPA_Int# :: Int# -> Int# -> PArray_Int# -> PArray_Int#
repeatPA_Int# n# len# is = U.repeat (I# n#) (I# len#) is
indexPA_Int# :: PArray_Int# -> Int# -> Int#
indexPA_Int# ns i# = case ns U.!: I# i# of { I# n# -> n# }
extractPA_Int# :: PArray_Int# -> Int# -> Int# -> PArray_Int#
extractPA_Int# xs i# n# = U.extract xs (I# i#) (I# n#)
bpermutePA_Int# :: PArray_Int# -> PArray_Int# -> PArray_Int#
bpermutePA_Int# ns is = U.bpermute ns is
appPA_Int# :: PArray_Int# -> PArray_Int# -> PArray_Int#
appPA_Int# ms ns = ms U.+:+ ns
applPA_Int# :: Segd -> Segd -> PArray_Int# -> Segd -> PArray_Int# -> PArray_Int#
applPA_Int# segd is xs js ys = U.append_s segd is xs js ys
pack'PA_Int# :: PArray_Int# -> PArray_Bool# -> PArray_Int#
pack'PA_Int# ns bs = U.pack ns bs
packPA_Int# :: PArray_Int# -> Int# -> PArray_Bool# -> PArray_Int#
packPA_Int# ns _ bs = pack'PA_Int# ns bs
combine2'PA_Int# :: PArray_Int# -> PArray_Int# -> PArray_Int# -> PArray_Int#
combine2'PA_Int# sel xs ys = U.combine (U.map (== 0) sel) xs ys
combine2PA_Int# :: Int# -> PArray_Int# -> PArray_Int#
-> PArray_Int# -> PArray_Int# -> PArray_Int#
combine2PA_Int# _ sel _ xs ys = combine2'PA_Int# sel xs ys
fromListPA_Int# :: Int# -> [Int] -> PArray_Int#
fromListPA_Int# _ xs = U.fromList xs
upToPA_Int# :: Int# -> PArray_Int#
upToPA_Int# n# = U.enumFromTo 0 (I# n# 1)
enumFromToPA_Int# :: Int# -> Int# -> PArray_Int#
enumFromToPA_Int# m# n# = U.enumFromTo (I# m#) (I# n#)
enumFromThenToPA_Int# :: Int# -> Int# -> Int# -> PArray_Int#
enumFromThenToPA_Int# k# m# n# = U.enumFromThenTo (I# k#) (I# m#) (I# n#)
enumFromStepLenPA_Int# :: Int# -> Int# -> Int# -> PArray_Int#
enumFromStepLenPA_Int# k# m# n# = U.enumFromStepLen (I# k#) (I# m#) (I# n#)
selectPA_Int# :: PArray_Int# -> Int# -> PArray_Bool#
selectPA_Int# ns i# = U.map (\n -> n == I# i#) ns
selectorToIndices2PA# :: PArray_Int# -> PArray_Int#
selectorToIndices2PA# sel
= U.zipWith pick sel
. U.scan index (0,0)
$ U.map init' sel
where
init' 0 = (1,0)
init' _ = (0,1)
index (i1,j1) (i2,j2) = (i1+i2,j1+j2)
pick 0 (i,_) = i
pick _ (_,j) = j
sumPA_Int# :: PArray_Int# -> Int#
sumPA_Int# ns = case U.sum ns of I# n# -> n#
sumPAs_Int# :: Segd -> PArray_Int# -> PArray_Int#
sumPAs_Int# segd ds = U.sum_s segd ds
unsafe_mapPA_Int# :: (Int -> Int) -> PArray_Int# -> PArray_Int#
unsafe_mapPA_Int# f ns = U.map f ns
unsafe_zipWithPA_Int# :: (Int -> Int -> Int)
-> PArray_Int# -> PArray_Int# -> PArray_Int#
unsafe_zipWithPA_Int# f ms ns = U.zipWith f ms ns
unsafe_foldPA_Int# :: (Int -> Int -> Int) -> Int -> PArray_Int# -> Int
unsafe_foldPA_Int# f z ns = U.fold f z ns
unsafe_scanPA_Int# :: (Int -> Int -> Int) -> Int -> PArray_Int# -> PArray_Int#
unsafe_scanPA_Int# f z ns = U.scan f z ns
type PArray_Word8# = U.Array Word8
lengthPA_Word8# :: PArray_Word8# -> Int#
lengthPA_Word8# arr = case U.length arr of { I# n# -> n# }
emptyPA_Word8# :: PArray_Word8#
emptyPA_Word8# = U.empty
replicatePA_Word8# :: Int# -> Word# -> PArray_Word8#
replicatePA_Word8# n# d# = U.replicate (I# n#) (W8# d#)
replicatelPA_Word8# :: Segd -> PArray_Word8# -> PArray_Word8#
replicatelPA_Word8# segd ds = U.replicate_s segd ds
repeatPA_Word8# :: Int# -> Int# -> PArray_Word8# -> PArray_Word8#
repeatPA_Word8# n# len# ds = U.repeat (I# n#) (I# len#) ds
indexPA_Word8# :: PArray_Word8# -> Int# -> Word#
indexPA_Word8# ds i# = case ds U.!: I# i# of { W8# d# -> d# }
extractPA_Word8# :: PArray_Word8# -> Int# -> Int# -> PArray_Word8#
extractPA_Word8# xs i# n# = U.extract xs (I# i#) (I# n#)
bpermutePA_Word8# :: PArray_Word8# -> PArray_Int# -> PArray_Word8#
bpermutePA_Word8# ds is = U.bpermute ds is
appPA_Word8# :: PArray_Word8# -> PArray_Word8# -> PArray_Word8#
appPA_Word8# ms ns = ms U.+:+ ns
applPA_Word8# :: Segd -> Segd -> PArray_Word8# -> Segd -> PArray_Word8#
-> PArray_Word8#
applPA_Word8# segd is xs js ys = U.append_s segd is xs js ys
pack'PA_Word8# :: PArray_Word8# -> PArray_Bool# -> PArray_Word8#
pack'PA_Word8# ns bs = U.pack ns bs
packPA_Word8# :: PArray_Word8# -> Int# -> PArray_Bool# -> PArray_Word8#
packPA_Word8# ns _ bs = pack'PA_Word8# ns bs
combine2'PA_Word8# :: PArray_Int#
-> PArray_Word8# -> PArray_Word8# -> PArray_Word8#
combine2'PA_Word8# sel xs ys = U.combine (U.map (== 0) sel) xs ys
combine2PA_Word8# :: Int# -> PArray_Int# -> PArray_Int#
-> PArray_Word8# -> PArray_Word8# -> PArray_Word8#
combine2PA_Word8# _ sel _ xs ys = combine2'PA_Word8# sel xs ys
fromListPA_Word8# :: Int# -> [Word8] -> PArray_Word8#
fromListPA_Word8# _ xs = U.fromList xs
unsafe_zipWithPA_Word8# :: (Word8 -> Word8 -> Word8)
-> PArray_Word8# -> PArray_Word8# -> PArray_Word8#
unsafe_zipWithPA_Word8# f ms ns = U.zipWith f ms ns
unsafe_foldPA_Word8# :: (Word8 -> Word8 -> Word8)
-> Word8 -> PArray_Word8# -> Word8
unsafe_foldPA_Word8# f z ns = U.fold f z ns
unsafe_fold1PA_Word8#
:: (Word8 -> Word8 -> Word8) -> PArray_Word8# -> Word8
unsafe_fold1PA_Word8# f ns = U.fold1 f ns
unsafe_foldPAs_Word8# :: (Word8 -> Word8 -> Word8) -> Word8
-> Segd -> PArray_Word8# -> PArray_Word8#
unsafe_foldPAs_Word8# f z segd ds = U.fold_s f z segd ds
type PArray_Double# = U.Array Double
lengthPA_Double# :: PArray_Double# -> Int#
lengthPA_Double# arr = case U.length arr of { I# n# -> n# }
emptyPA_Double# :: PArray_Double#
emptyPA_Double# = U.empty
replicatePA_Double# :: Int# -> Double# -> PArray_Double#
replicatePA_Double# n# d# = U.replicate (I# n#) (D# d#)
replicatelPA_Double# :: Segd -> PArray_Double# -> PArray_Double#
replicatelPA_Double# segd ds = U.replicate_s segd ds
repeatPA_Double# :: Int# -> Int# -> PArray_Double# -> PArray_Double#
repeatPA_Double# n# len# ds = U.repeat (I# n#) (I# len#) ds
indexPA_Double# :: PArray_Double# -> Int# -> Double#
indexPA_Double# ds i# = case ds U.!: I# i# of { D# d# -> d# }
extractPA_Double# :: PArray_Double# -> Int# -> Int# -> PArray_Double#
extractPA_Double# xs i# n# = U.extract xs (I# i#) (I# n#)
bpermutePA_Double# :: PArray_Double# -> PArray_Int# -> PArray_Double#
bpermutePA_Double# ds is = U.bpermute ds is
appPA_Double# :: PArray_Double# -> PArray_Double# -> PArray_Double#
appPA_Double# ms ns = ms U.+:+ ns
applPA_Double# :: Segd -> Segd -> PArray_Double# -> Segd -> PArray_Double#
-> PArray_Double#
applPA_Double# segd is xs js ys = U.append_s segd is xs js ys
pack'PA_Double# :: PArray_Double# -> PArray_Bool# -> PArray_Double#
pack'PA_Double# ns bs = U.pack ns bs
packPA_Double# :: PArray_Double# -> Int# -> PArray_Bool# -> PArray_Double#
packPA_Double# ns _ bs = pack'PA_Double# ns bs
combine2'PA_Double# :: PArray_Int#
-> PArray_Double# -> PArray_Double# -> PArray_Double#
combine2'PA_Double# sel xs ys = U.combine (U.map (== 0) sel) xs ys
combine2PA_Double# :: Int# -> PArray_Int# -> PArray_Int#
-> PArray_Double# -> PArray_Double# -> PArray_Double#
combine2PA_Double# _ sel _ xs ys = combine2'PA_Double# sel xs ys
fromListPA_Double# :: Int# -> [Double] -> PArray_Double#
fromListPA_Double# _ xs = U.fromList xs
unsafe_zipWithPA_Double# :: (Double -> Double -> Double)
-> PArray_Double# -> PArray_Double# -> PArray_Double#
unsafe_zipWithPA_Double# f ms ns = U.zipWith f ms ns
unsafe_foldPA_Double# :: (Double -> Double -> Double)
-> Double -> PArray_Double# -> Double
unsafe_foldPA_Double# f z ns = U.fold f z ns
unsafe_fold1PA_Double#
:: (Double -> Double -> Double) -> PArray_Double# -> Double
unsafe_fold1PA_Double# f ns = U.fold1 f ns
unsafe_foldPAs_Double# :: (Double -> Double -> Double) -> Double
-> Segd -> PArray_Double# -> PArray_Double#
unsafe_foldPAs_Double# f z segd ds = U.fold_s f z segd ds
type PArray_Bool# = U.Array Bool
lengthPA_Bool# :: PArray_Bool# -> Int#
lengthPA_Bool# arr = case U.length arr of { I# n# -> n# }
replicatelPA_Bool# :: Segd -> PArray_Bool# -> PArray_Bool#
replicatelPA_Bool# segd ds = U.replicate_s segd ds
packPA_Bool# :: PArray_Bool# -> Int# -> PArray_Bool# -> PArray_Bool#
packPA_Bool# ns _ bs = U.pack ns bs
truesPA_Bool# :: PArray_Bool# -> Int#
truesPA_Bool# bs = sumPA_Int# (fromBoolPA# bs)
truesPAs_Bool# :: Segd -> PArray_Bool# -> PArray_Int#
truesPAs_Bool# segd = sumPAs_Int# segd . fromBoolPA#
fromBoolPA# :: PArray_Bool# -> PArray_Int#
fromBoolPA# = U.map (tagToInt . fromBool)
toBoolPA# :: PArray_Int# -> PArray_Bool#
toBoolPA# = U.map (toBool . intToTag)