module Data.Array.Parallel.Prelude.Word8
( Word8
, (==), (/=), (<), (<=), (>), (>=), min, max
, maximumP, minimumP
, maxIndexP, minIndexP
, (+), (), (*)
, negate, abs
, sumP, productP
, div, mod, sqrt
, fromInt
, toInt)
where
import Data.Array.Parallel.Prim ()
import Data.Array.Parallel.Prelude.Base (Bool, Int, Word8, Eq, Ord, Num)
import Data.Array.Parallel.PArr
import Data.Array.Parallel.PArray
import Data.Array.Parallel.Lifted ((:->)(..))
import qualified Data.Array.Parallel.Lifted as L
import qualified Data.Array.Parallel.PArray.Scalar as SC
import qualified Prelude as P
infixl 7 *
infixl 6 +,
infix 4 ==, /=, <, <=, >, >=
infixl 7 `div`, `mod`
(==), (/=), (<), (<=), (>), (>=) :: Word8 -> Word8 -> Bool
(==) = (P.==)
(/=) = (P./=)
(<=) = (P.<=)
(<) = (P.<)
(>=) = (P.>=)
(>) = (P.>)
min, max :: Word8 -> Word8 -> Word8
min = P.min
max = P.max
minimumP, maximumP :: PArr Word8 -> Word8
minimumP arr = headPArr arr
maximumP arr = headPArr arr
minimumPP, maximumPP :: PArray Word8 :-> Word8
minimumPP = L.closure1' (SC.fold1 P.min) (SC.fold1s P.min)
maximumPP = L.closure1' (SC.fold1 P.max) (SC.fold1s P.max)
minIndexP :: PArr Word8 -> Int
minIndexP !_ = 0
minIndexPP :: PArray Word8 :-> Int
minIndexPP = L.closure1' (SC.fold1Index min') (SC.fold1sIndex min')
min' :: P.Ord b => (a, b) -> (a, b) -> (a, b)
min' (i,x) (j,y) | x P.<= y = (i,x)
| P.otherwise = (j,y)
maxIndexP :: PArr Word8 -> Int
maxIndexP _ = 0
maxIndexPP :: PArray Word8 :-> Int
maxIndexPP = L.closure1' (SC.fold1Index max') (SC.fold1sIndex max')
max' :: P.Ord b => (a, b) -> (a, b) -> (a, b)
max' (i,x) (j,y) | x P.>= y = (i,x)
| P.otherwise = (j,y)
(+), (), (*) :: Word8 -> Word8 -> Word8
(+) = (P.+)
() = (P.-)
(*) = (P.*)
negate, abs :: Word8 -> Word8
negate = P.negate
abs = P.abs
sumP, productP :: PArr Word8 -> Word8
sumP arr = headPArr arr
productP arr = headPArr arr
sumPP, productPP :: PArray Word8 :-> Word8
sumPP = L.closure1' (SC.fold (+) 0) (SC.folds (+) 0)
productPP = L.closure1' (SC.fold (*) 1) (SC.folds (*) 1)
div, mod :: Word8 -> Word8 -> Word8
div = P.div
mod = P.mod
sqrt :: Word8 -> Word8
sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
toInt :: Word8 -> Int
toInt = P.fromIntegral
fromInt :: Int -> Word8
fromInt = P.fromIntegral