#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_zipWith4
:: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e)
=> (a -> b -> c -> d -> e) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e
scalar_zipWith4 f ws xs ys zs
= fromUArray' (prim_lengthPA ws)
$ U.zipWith4 f (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
scalar_zipWith5
:: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f)
=> (a -> b -> c -> d -> e -> f) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f
scalar_zipWith5 f vs ws xs ys zs
= fromUArray' (prim_lengthPA vs)
$ U.zipWith5 f (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
scalar_zipWith6
:: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g)
=> (a -> b -> c -> d -> e -> f -> g)
-> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f-> PArray g
scalar_zipWith6 f us vs ws xs ys zs
= fromUArray' (prim_lengthPA us)
$ U.zipWith6 f (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
scalar_zipWith7
:: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g, Scalar h)
=> (a -> b -> c -> d -> e -> f -> g -> h)
-> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f-> PArray g -> PArray h
scalar_zipWith7 f ts us vs ws xs ys zs
= fromUArray' (prim_lengthPA us)
$ U.zipWith7 f (toUArray ts) (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
scalar_zipWith8
:: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g, Scalar h, Scalar i)
=> (a -> b -> c -> d -> e -> f -> g -> h -> i)
-> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f-> PArray g -> PArray h -> PArray i
scalar_zipWith8 f ss ts us vs ws xs ys zs
= fromUArray' (prim_lengthPA ss)
$ U.zipWith8 f (toUArray ss) (toUArray ts) (toUArray us) (toUArray vs) (toUArray ws) (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