#include "fusion-phases.h"
module Data.Array.Parallel.Prim
( PData, PDatas, PRepr, PA(..), PR(..)
, emptyPD
, replicatePD
, packByTagPD
, combine2PD
, Scalar(..)
, scalar_map
, scalar_zipWith
, scalar_zipWith3
, scalar_zipWith4
, scalar_zipWith5
, scalar_zipWith6
, scalar_zipWith7
, scalar_zipWith8
, Void, void, fromVoid, pvoid, pvoids#
, punit
, Wrap(..)
, Sum2(..), Sum3(..)
, (:->)(..)
, closure, ($:)
, liftedClosure, liftedApply
, closure1, closure2, closure3, closure4, closure5
, closure6, closure7, closure8
, Sel2
, tagsSel2
, pickSel2#
, replicateSel2#
, elementsSel2_0#
, elementsSel2_1#
, Sels2
, lengthSels2#
, emptyPA_Int#, emptyPA_Double#
, replicatePA_Int#, replicatePA_Double#
, packByTagPA_Int#, packByTagPA_Double#
, combine2PA_Int#, combine2PA_Double#
, tup2, tup3, tup4, tup5)
where
import Data.Array.Parallel.PArray.PData.Base
(PArray(..), PData, PDatas, PR(..))
import Data.Array.Parallel.PArray.PData.Void
( Void, void, pvoid, pvoids, fromVoid )
import Data.Array.Parallel.PArray.PData.Unit
( punit )
import Data.Array.Parallel.PArray.PData.Sum2
( Sels2, lengthSels2 )
import Data.Array.Parallel.PArray.PRepr
( PRepr, PA(..)
, emptyPA, replicatePA, packByTagPA, combine2PA)
import Data.Array.Parallel.PArray.Scalar
( Scalar(..))
import Data.Array.Parallel.PArray.Types
( Wrap(..)
, Sum2(..), Sum3(..))
import Data.Array.Parallel.Lifted.Closure
( (:->)(..))
import Data.Array.Parallel.Prelude.Tuple
( tup2, tup3, tup4, tup5)
import Data.Array.Parallel.Base (Tag, intToTag)
import qualified Data.Array.Parallel.Unlifted as U
import qualified Data.Array.Parallel.PArray.Scalar as Scalar
import qualified Data.Array.Parallel.Lifted.Closure as C
import GHC.Exts
emptyPD :: PA a => PData a
emptyPD = emptyPA
replicatePD :: PA a => Int# -> a -> PData a
replicatePD i# x
= replicatePA (I# i#) x
packByTagPD :: PA a => PData a -> Int# -> U.Array Tag -> Int# -> PData a
packByTagPD xs _ tags tag#
= packByTagPA xs tags (I# tag#)
combine2PD :: PA a => Int# -> U.Sel2 -> PData a -> PData a -> PData a
combine2PD _ sel xs ys
= combine2PA sel xs ys
pvoids# :: Int# -> PDatas Void
pvoids# n# = pvoids (I# n#)
closure :: forall a b e
. PA e
=> (e -> a -> b)
-> (Int# -> PData e -> PData a -> PData b)
-> e
-> (a :-> b)
closure fv fl e
= Clo fv
(\(I# c) v x -> fl c v x)
e
($:) :: forall a b. (a :-> b) -> a -> b
($:) = (C.$:)
liftedClosure
:: forall a b e
. PA e
=> (e -> a -> b)
-> (Int# -> PData e -> PData a -> PData b)
-> PData e
-> PData (a :-> b)
liftedClosure fv fl es
= C.AClo fv
(\(I# c) v x -> fl c v x)
es
liftedApply :: Int# -> PData (a :-> b) -> PData a -> PData b
liftedApply n# arr xs
= C.liftedApply (I# n#) arr xs
closure1 :: forall a b
. (a -> b)
-> (PArray a -> PArray b)
-> (a :-> b)
closure1 fv fl
= let fl' :: Int -> PData a -> PData b
fl' (I# c#) pdata
= case fl (PArray c# pdata) of
PArray _ pdata' -> pdata'
in C.closure1 fv fl'
closure2 :: forall a b c. PA a
=> (a -> b -> c)
-> (PArray a -> PArray b -> PArray c)
-> (a :-> b :-> c)
closure2 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c
fl' (I# c#) pdata1 pdata2
= case fl (PArray c# pdata1) (PArray c# pdata2) of
PArray _ pdata' -> pdata'
in C.closure2 fv fl'
closure3 :: forall a b c d. (PA a, PA b)
=> (a -> b -> c -> d)
-> (PArray a -> PArray b -> PArray c -> PArray d)
-> (a :-> b :-> c :-> d)
closure3 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c -> PData d
fl' (I# c#) pdata1 pdata2 pdata3
= case fl (PArray c# pdata1) (PArray c# pdata2) (PArray c# pdata3) of
PArray _ pdata' -> pdata'
in C.closure3 fv fl'
closure4 :: forall a b c d e. (PA a, PA b, PA c)
=> (a -> b -> c -> d -> e)
-> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e)
-> (a :-> b :-> c :-> d :-> e)
closure4 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c -> PData d -> PData e
fl' (I# c#) pdata1 pdata2 pdata3 pdata4
= case fl (PArray c# pdata1) (PArray c# pdata2) (PArray c# pdata3) (PArray c# pdata4) of
PArray _ pdata' -> pdata'
in C.closure4 fv fl'
closure5 :: forall a b c d e f. (PA a, PA b, PA c, PA d)
=> (a -> b -> c -> d -> e -> f)
-> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f)
-> (a :-> b :-> c :-> d :-> e :-> f)
closure5 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c -> PData d -> PData e -> PData f
fl' (I# c#) pdata1 pdata2 pdata3 pdata4 pdata5
= case fl (PArray c# pdata1) (PArray c# pdata2) (PArray c# pdata3) (PArray c# pdata4) (PArray c# pdata5) of
PArray _ pdata' -> pdata'
in C.closure5 fv fl'
closure6 :: forall a b c d e f g. (PA a, PA b, PA c, PA d, PA e)
=> (a -> b -> c -> d -> e -> f -> g)
-> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g)
-> (a :-> b :-> c :-> d :-> e :-> f :-> g)
closure6 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c -> PData d -> PData e -> PData f -> PData g
fl' (I# c#) pdata1 pdata2 pdata3 pdata4 pdata5 pdata6
= case fl (PArray c# pdata1) (PArray c# pdata2) (PArray c# pdata3) (PArray c# pdata4) (PArray c# pdata5) (PArray c# pdata6) of
PArray _ pdata' -> pdata'
in C.closure6 fv fl'
closure7 :: forall a b c d e f g h. (PA a, PA b, PA c, PA d, PA e, PA f, PA g)
=> (a -> b -> c -> d -> e -> f -> g -> h)
-> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g -> PArray h)
-> (a :-> b :-> c :-> d :-> e :-> f :-> g :-> h)
closure7 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c -> PData d -> PData e -> PData f -> PData g -> PData h
fl' (I# c#) pdata1 pdata2 pdata3 pdata4 pdata5 pdata6 pdata7
= case fl (PArray c# pdata1) (PArray c# pdata2) (PArray c# pdata3) (PArray c# pdata4) (PArray c# pdata5) (PArray c# pdata6) (PArray c# pdata7) of
PArray _ pdata' -> pdata'
in C.closure7 fv fl'
closure8 :: forall a b c d e f g h i. (PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h)
=> (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)
-> (a :-> b :-> c :-> d :-> e :-> f :-> g :-> h :-> i)
closure8 fv fl
= let fl' :: Int -> PData a -> PData b -> PData c -> PData d -> PData e -> PData f -> PData g -> PData h -> PData i
fl' (I# c#) pdata1 pdata2 pdata3 pdata4 pdata5 pdata6 pdata7 pdata8
= case fl (PArray c# pdata1) (PArray c# pdata2) (PArray c# pdata3) (PArray c# pdata4)
(PArray c# pdata5) (PArray c# pdata6) (PArray c# pdata7) (PArray c# pdata8) of
PArray _ pdata' -> pdata'
in C.closure8 fv fl'
type Sel2 = U.Sel2
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# }
lengthSels2# :: Sels2 -> Int#
lengthSels2# sels2
= case lengthSels2 sels2 of { I# n# -> n# }
scalar_map
:: (Scalar a, Scalar b)
=> (a -> b) -> PArray a -> PArray b
scalar_map = Scalar.map
scalar_zipWith
:: (Scalar a, Scalar b, Scalar c)
=> (a -> b -> c) -> PArray a -> PArray b -> PArray c
scalar_zipWith = Scalar.zipWith
scalar_zipWith3
:: (Scalar a, Scalar b, Scalar c, Scalar d)
=> (a -> b -> c -> d) -> PArray a -> PArray b -> PArray c -> PArray d
scalar_zipWith3 = Scalar.zipWith3
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 = Scalar.zipWith4
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 = Scalar.zipWith5
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 = Scalar.zipWith6
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 = Scalar.zipWith7
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 = Scalar.zipWith8
type PArray_Int# = U.Array Int
replicatePA_Int# :: Int# -> Int# -> PArray_Int#
replicatePA_Int# n# i# = U.replicate (I# n#) (I# i#)
emptyPA_Int# :: PArray_Int#
emptyPA_Int# = U.empty
packByTagPA_Int# :: a
packByTagPA_Int#
= error "Data.Array.Parallel.Prim: 'packByTagPA_Int#' not implemented"
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
type PArray_Double# = U.Array Double
replicatePA_Double# :: Int# -> Double# -> PArray_Double#
replicatePA_Double# n# d# = U.replicate (I# n#) (D# d#)
emptyPA_Double# :: PArray_Double#
emptyPA_Double# = U.empty
packByTagPA_Double# :: a
packByTagPA_Double#
= error "Data.Array.Parallel.Prim: 'packByTagPA_Double#' not implemented"
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