#include "fusion-phases.h"
module Data.Array.Parallel.Lifted.Scalar
where
import Data.Array.Parallel.Lifted.PArray
import Data.Array.Parallel.PArray.PReprInstances
import Data.Array.Parallel.PArray.PDataInstances
import qualified Data.Array.Parallel.Unlifted as U
import Data.Array.Parallel.Base (fromBool, toBool)
import GHC.Exts (Int(..))
instance Scalar Bool where
toScalarPData bs
= PBool (U.tagsToSel2 (U.map fromBool bs))
fromScalarPData (PBool sel) = U.map toBool (U.tagsSel2 sel)
prim_lengthPA :: Scalar a => PArray a -> Int
prim_lengthPA xs = I# (lengthPA# xs)
fromUArray :: Scalar a => U.Array a -> PArray a
fromUArray xs
= let !(I# n#) = U.length xs
in PArray n# (toScalarPData xs)
fromUArray' :: Scalar a => Int -> U.Array a -> PArray a
fromUArray' (I# n#) xs
= PArray n# (toScalarPData xs)
toUArray :: Scalar a => PArray a -> U.Array a
toUArray (PArray _ xs) = fromScalarPData xs
fromUArray2
:: (Scalar a, Scalar b)
=> U.Array (a,b) -> PArray (a,b)
fromUArray2 ps
= let !(I# n#) = U.length ps
(xs, ys) = U.unzip ps
in PArray n# (P_2 (toScalarPData xs) (toScalarPData ys))
fromUArray3
:: (Scalar a, Scalar b, Scalar c)
=> U.Array ((a,b),c) -> PArray (a,b,c)
fromUArray3 ps
= let !(I# n#) = U.length ps
(qs,zs) = U.unzip ps
(xs,ys) = U.unzip qs
in PArray n# (P_3 (toScalarPData xs)
(toScalarPData ys)
(toScalarPData zs))
nestUSegd
:: U.Segd
-> PArray a
-> PArray (PArray a)
nestUSegd segd (PArray _ xs)
= let !(I# n#) = U.lengthSegd segd
in PArray n# (PNested segd xs)
scalar_map
:: (Scalar a, Scalar b)
=> (a -> b) -> PArray a -> PArray b
scalar_map f xs
= fromUArray' (prim_lengthPA xs)
. U.map f
$ toUArray xs
scalar_zipWith
:: (Scalar a, Scalar b, Scalar c)
=> (a -> b -> c) -> PArray a -> PArray b -> PArray c
scalar_zipWith f xs ys
= fromUArray' (prim_lengthPA xs)
$ U.zipWith f (toUArray xs) (toUArray ys)
scalar_zipWith3
:: (Scalar a, Scalar b, Scalar c, Scalar d)
=> (a -> b -> c -> d) -> PArray a -> PArray b -> PArray c -> PArray d
scalar_zipWith3 f xs ys zs
= fromUArray' (prim_lengthPA xs)
$ U.zipWith3 f (toUArray xs) (toUArray ys) (toUArray zs)
scalar_fold
:: Scalar a
=> (a -> a -> a) -> a -> PArray a -> a
scalar_fold f z
= U.fold f z . toUArray
scalar_fold1
:: Scalar a
=> (a -> a -> a) -> PArray a -> a
scalar_fold1 f
= U.fold1 f . toUArray
scalar_folds
:: Scalar a
=> (a -> a -> a) -> a -> PArray (PArray a) -> PArray a
scalar_folds f z xss
= fromUArray' (prim_lengthPA (concatPA# xss))
. U.fold_s f z (segdPA# xss)
. toUArray
$ concatPA# xss
scalar_fold1s
:: Scalar a
=> (a -> a -> a) -> PArray (PArray a) -> PArray a
scalar_fold1s f xss
= fromUArray' (prim_lengthPA (concatPA# xss))
. U.fold1_s f (segdPA# xss)
. toUArray
$ concatPA# xss
scalar_fold1Index
:: Scalar a
=> ((Int, a) -> (Int, a) -> (Int, a)) -> PArray a -> Int
scalar_fold1Index f
= fst . U.fold1 f . U.indexed . toUArray
scalar_fold1sIndex
:: Scalar a
=> ((Int, a) -> (Int, a) -> (Int, a))
-> PArray (PArray a) -> PArray Int
scalar_fold1sIndex f (PArray m# (PNested segd xs))
= PArray m#
$ toScalarPData
$ U.fsts
$ U.fold1_s f segd
$ U.zip (U.indices_s segd)
$ fromScalarPData xs