#include "fusion-phases.h"
module Data.Array.Parallel.PArray.Scalar
( Scalar(..)
, toUArray, fromUArray
, fromUArray2
, map
, zipWith
, zipWith3
, fold, folds
, fold1, fold1s
, fold1Index, fold1sIndex
, enumFromTo, enumFromTol)
where
import Data.Array.Parallel.PArray.PData.Void
import Data.Array.Parallel.PArray.PData.Word8
import Data.Array.Parallel.PArray.PData.Double
import Data.Array.Parallel.PArray.PData
import Data.Array.Parallel.PArray.PRepr
import Data.Array.Parallel.Base
import Data.Word
import GHC.Exts
import qualified Data.Array.Parallel.Unlifted as U
import Prelude hiding ( map, zipWith, zipWith3, enumFromTo)
class (PA a, U.Elt a) => Scalar a where
fromScalarPData :: PData a -> U.Array a
toScalarPData :: U.Array a -> PData a
fromScalarPDatas :: PDatas a -> U.Arrays a
toScalarPDatas :: U.Arrays a -> PDatas a
from :: Scalar a => PData a -> U.Array a
from = fromScalarPData
to :: Scalar a => U.Array a -> PData a
to = toScalarPData
instance Scalar Bool where
toScalarPData bs
= PBool (U.tagsToSel2 (U.map fromBool bs))
fromScalarPData (PBool sel)
= U.map toBool (U.tagsSel2 sel)
fromScalarPDatas _
= error "Data.Array.Parallel.PArray.Lifted.Scalar: no Arrays instance for Bool."
toScalarPDatas _
= error "Data.Array.Parallel.PArray.Lifted.Scalar: no Arrays instance for Bool."
instance U.Elt Ordering
instance Scalar Ordering where
toScalarPData
= POrdering . U.map toPRepr
fromScalarPData (POrdering w8s)
= U.map fromPRepr w8s
toScalarPDatas _
= error "Data.Array.Parallel.PArray.Lifted.Scalar: no 'Arrays' instance for 'Ordering'."
fromScalarPDatas _
= error "Data.Array.Parallel.PArray.Lifted.Scalar: no 'Arrays' instance for 'Ordering'."
type instance PRepr Integer = Void
data instance PData Integer = PInteger
data instance PDatas Integer = PIntegers
instance PA Integer
instance U.Elt Integer
instance Scalar Integer where
toScalarPData = fakeScalarInteger
fromScalarPData = fakeScalarInteger
toScalarPDatas = fakeScalarInteger
fromScalarPDatas = fakeScalarInteger
fakeScalarInteger :: a
fakeScalarInteger = error "D.A.P.PArray.Scalar: fake instance 'Scalar Integer'"
instance Scalar Int where
fromScalarPData (PInt xs) = xs `seq` xs
fromScalarPDatas (PInts xss) = xss `seq` xss
toScalarPData = PInt
toScalarPDatas = PInts
instance Scalar Word8 where
fromScalarPData (PWord8 xs) = xs `seq` xs
fromScalarPDatas (PWord8s xss) = xss `seq` xss
toScalarPData = PWord8
toScalarPDatas = PWord8s
instance Scalar Double where
fromScalarPData (PDouble xs) = xs `seq` xs
fromScalarPDatas (PDoubles xss) = xss `seq` xss
toScalarPData = PDouble
toScalarPDatas = PDoubles
fromUArray :: Scalar a => U.Array a -> PArray a
fromUArray uarr
= let !(I# n#) = U.length uarr
in PArray n# (toScalarPData uarr)
toUArray :: Scalar a => PArray a -> U.Array a
toUArray (PArray _ pdata)
= fromScalarPData pdata
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# (PTuple2 (toScalarPData xs) (toScalarPData ys))
map :: (Scalar a, Scalar b)
=> (a -> b) -> PArray a -> PArray b
map f (PArray len xs)
= PArray len $ to $ U.map f (from xs)
zipWith :: (Scalar a, Scalar b, Scalar c)
=> (a -> b -> c) -> PArray a -> PArray b -> PArray c
zipWith f (PArray len xs) (PArray _ ys)
= PArray len $ to $ U.zipWith f (from xs) (from ys)
zipWith3
:: (Scalar a, Scalar b, Scalar c, Scalar d)
=> (a -> b -> c -> d) -> PArray a -> PArray b -> PArray c -> PArray d
zipWith3 f (PArray len xs) (PArray _ ys) (PArray _ zs)
= PArray len $ to $ U.zipWith3 f (from xs) (from ys) (from zs)
fold :: Scalar a
=> (a -> a -> a) -> a -> PArray a -> a
fold f !z (PArray _ pdata)
= U.fold f z $ from pdata
fold1 :: Scalar a
=> (a -> a -> a) -> PArray a -> a
fold1 f (PArray _ pdata)
= U.fold1 f $ from pdata
folds :: (Scalar a, U.Elts a)
=> (a -> a -> a) -> a -> PArray (PArray a) -> PArray a
folds f !z (PArray _ (PNested vsegd pdatas _ _))
= pdatas `seq`
fromUArray $ U.fold_vs f z vsegd $ fromScalarPDatas pdatas
fold1s :: (Scalar a, U.Elts a)
=> (a -> a -> a) -> PArray (PArray a) -> PArray a
fold1s f (PArray _ (PNested vsegd pdatas _ _))
= pdatas `seq`
fromUArray $ U.fold1_vs f vsegd $ fromScalarPDatas pdatas
fold1Index
:: Scalar a
=> ((Int, a) -> (Int, a) -> (Int, a)) -> PArray a -> Int
fold1Index f
= fst . U.fold1 f . U.indexed . toUArray
fold1sIndex
:: Scalar a
=> ((Int, a) -> (Int, a) -> (Int, a))
-> PArray (PArray a) -> PArray Int
fold1sIndex f (PArray n# pdata)
= let segd = takeSegdPD pdata
xs = concatPA pdata
in PArray n#
$ toScalarPData
$ U.fsts
$ U.fold1_s f segd
$ U.zip (U.indices_s segd)
$ fromScalarPData xs
enumFromTo :: Int -> Int -> PArray Int
enumFromTo m n
= fromUArray (U.enumFromTo m n)
enumFromTol :: PArray Int -> PArray Int -> PArray (PArray Int)
enumFromTol (PArray m# ms) (PArray _ ns)
= let
lens = U.zipWith distance (fromScalarPData ms) (fromScalarPData ns)
segd = U.lengthsToSegd lens
flat = toScalarPData
$ U.enumFromStepLenEach
(U.elementsSegd segd)
(fromScalarPData ms)
(U.replicate (U.elementsSegd segd) 1)
lens
vsegd = U.promoteSegdToVSegd segd
pdatas = singletondPA flat
in PArray m# $ PNested vsegd pdatas segd flat
distance :: Int -> Int -> Int
distance m n = max 0 (n m + 1)