module Data.Array.Parallel.Prelude.Int (
Int,
(==), (/=), (<), (<=), (>), (>=), min, max,
minimumP, maximumP, minIndexP, maxIndexP,
(+), (), (*), negate, abs,
sumP, productP,
div, mod, sqrt,
enumFromToP
) where
import Data.Array.Parallel.Prim ()
import Data.Array.Parallel.Prelude.Base
import Data.Array.Parallel.PArr
import Data.Array.Parallel.Lifted.Combinators
import Data.Array.Parallel.Lifted.Scalar
import Data.Array.Parallel.Lifted.Closure
import qualified Prelude as P
infixl 7 *
infixl 6 +,
infix 4 ==, /=, <, <=, >, >=
infixl 7 `div`, `mod`
(==), (/=), (<), (<=), (>), (>=) :: Int -> Int -> Bool
(==) = (P.==)
(/=) = (P./=)
(<=) = (P.<=)
(<) = (P.<)
(>=) = (P.>=)
(>) = (P.>)
min, max :: Int -> Int -> Int
min = P.min
max = P.max
minimumP, maximumP :: PArr Int -> Int
minimumP a = a `indexPArr` 0
maximumP a = a `indexPArr` 0
minimumP_v, maximumP_v:: PArray Int :-> Int
minimumP_v = closure1 (scalar_fold1 P.min) (scalar_fold1s P.min)
maximumP_v = closure1 (scalar_fold1 P.max) (scalar_fold1s P.max)
minIndexP :: PArr Int -> Int
minIndexP _ = 0
minIndexPA :: PArray Int :-> Int
minIndexPA = closure1 (scalar_fold1Index min') (scalar_fold1sIndex min')
min' (i,x) (j,y) | x P.<= y = (i,x)
| P.otherwise = (j,y)
maxIndexP :: PArr Int -> Int
maxIndexP _ = 0
maxIndexPA :: PArray Int :-> Int
maxIndexPA = closure1 (scalar_fold1Index max') (scalar_fold1sIndex max')
max' (i,x) (j,y) | x P.>= y = (i,x)
| P.otherwise = (j,y)
(+), (), (*) :: Int -> Int -> Int
(+) = (P.+)
() = (P.-)
(*) = (P.*)
negate, abs :: Int -> Int
negate = P.negate
abs = P.abs
sumP, productP :: PArr Int -> Int
sumP a = a `indexPArr` 0
productP a = a `indexPArr` 0
sumP_v, productP_v:: PArray Int :-> Int
sumP_v = closure1 (scalar_fold (P.+) 0) (scalar_folds (P.+) 0)
productP_v = closure1 (scalar_fold (P.*) 1) (scalar_folds (P.*) 1)
div, mod :: Int -> Int -> Int
div = P.div
mod = P.mod
sqrt :: Int -> Int
sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
enumFromToP :: Int -> Int -> PArr Int
enumFromToP x y = singletonPArr (x P.+ y)