{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{- |
Support for unified handling of scalars and vectors.

Attention:
The rounding and fraction functions only work
for floating point values with maximum magnitude of @maxBound :: Int32@.
This way we save expensive handling of possibly seldom cases.
-}
module LLVM.Extra.ScalarOrVector (
   Fraction (truncate, fraction),
   signedFraction,
   addToPhase,
   incPhase,

   truncateToInt,
   floorToInt,
   ceilingToInt,
   roundToIntFast,
   splitFractionToInt,

   Scalar,
   Replicate (replicate, replicateConst),
   replicateOf,
   Real (min, max, abs, signum),
   Saturated(addSat, subSat),
   PseudoModule (scale),
   IntegerConstant(constFromInteger),
   RationalConstant(constFromRational),
   TranscendentalConstant(constPi),
   ) where

import qualified LLVM.Extra.ScalarOrVectorPrivate as Priv
import qualified LLVM.Extra.Vector as Vector
import qualified LLVM.Extra.ArithmeticPrivate as A
import LLVM.Extra.ScalarOrVectorPrivate
   (Scalar, Replicate(replicate, replicateConst))

import qualified LLVM.Util.Intrinsic as Intrinsic
import qualified LLVM.Util.Proxy as LP
import qualified LLVM.Core as LLVM
import LLVM.Core
   (Value, ConstValue, constOf,
    CmpRet, CmpResult, ShapeOf,
    Vector, WordN(WordN), IntN(IntN), FP128,
    IsConst, IsInteger, IsFloating,
    CodeGenFunction, )

import qualified Type.Data.Num.Decimal as TypeNum

import Data.Word (Word8, Word16, Word32, Word64, Word)
import Data.Int  (Int8,  Int16,  Int32,  Int64, )
import Data.Maybe (fromMaybe)

import Prelude hiding (Real, replicate, min, max, abs, truncate)



class (Real a, IsFloating a) => Fraction a where
   truncate :: Value a -> CodeGenFunction r (Value a)
   fraction :: Value a -> CodeGenFunction r (Value a)

instance Fraction Float where
   truncate :: forall r. Value Float -> CodeGenFunction r (Value Float)
truncate = Value Float -> CodeGenFunction r (Value Float)
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
Intrinsic.truncate
   fraction :: forall r. Value Float -> CodeGenFunction r (Value Float)
fraction = Value Float -> CodeGenFunction r (Value Float)
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
A.fraction

instance Fraction Double where
   truncate :: forall r. Value Double -> CodeGenFunction r (Value Double)
truncate = Value Double -> CodeGenFunction r (Value Double)
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
Intrinsic.truncate
   fraction :: forall r. Value Double -> CodeGenFunction r (Value Double)
fraction = Value Double -> CodeGenFunction r (Value Double)
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
A.fraction

instance (TypeNum.Positive n, Vector.Real a, IsFloating a, IsConst a) =>
      Fraction (Vector n a) where
   truncate :: forall r.
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
truncate = Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
Vector.truncate
   fraction :: forall r.
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
fraction = Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
Vector.fraction


{- |
The fraction has the same sign as the argument.
This is not particular useful but fast on IEEE implementations.
-}
signedFraction ::
   (Fraction a) =>
   Value a -> CodeGenFunction r (Value a)
signedFraction :: forall a r. Fraction a => Value a -> CodeGenFunction r (Value a)
signedFraction Value a
x =
   Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value a
x (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value a -> CodeGenFunction r (Value a)
forall r. Value a -> CodeGenFunction r (Value a)
forall a r. Fraction a => Value a -> CodeGenFunction r (Value a)
truncate Value a
x

_fractionGen ::
   (IntegerConstant v, Fraction v, CmpRet v) =>
   Value v -> CodeGenFunction r (Value v)
_fractionGen :: forall v r.
(IntegerConstant v, Fraction v, CmpRet v) =>
Value v -> CodeGenFunction r (Value v)
_fractionGen Value v
x =
   do Value v
xf <- Value v -> CodeGenFunction r (Value v)
forall a r. Fraction a => Value a -> CodeGenFunction r (Value a)
signedFraction Value v
x
      Value (ShapedType (ShapeOf v) Bool)
b <- FPPredicate
-> Value v
-> Value v
-> CodeGenFunction r (Value (ShapedType (ShapeOf v) Bool))
forall a b r.
(IsFloating a, CmpRet a, CmpResult a ~ b) =>
FPPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.fcmp FPPredicate
LLVM.FPOGE Value v
xf Value v
forall a. IsType a => Value a
zero
      Value (ShapedType (ShapeOf v) Bool)
-> Value v -> Value v -> CodeGenFunction r (Value v)
forall a r.
CmpRet a =>
Value (CmpResult a)
-> Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.select Value (ShapedType (ShapeOf v) Bool)
b Value v
xf (Value v -> CodeGenFunction r (Value v))
-> CodeGenFunction r (Value v) -> CodeGenFunction r (Value v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value v -> Value v -> CodeGenFunction r (Value v)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value v
xf (ConstValue v -> Value v
forall a. ConstValue a -> Value a
LLVM.value (ConstValue v -> Value v) -> ConstValue v -> Value v
forall a b. (a -> b) -> a -> b
$ Integer -> ConstValue v
forall a. IntegerConstant a => Integer -> ConstValue a
constFromInteger Integer
1)

_fractionLogical ::
   (Fraction a, LLVM.IsPrimitive a,
    IsInteger b, LLVM.IsPrimitive b) =>
   (LLVM.FPPredicate ->
    Value a -> Value a -> CodeGenFunction r (Value b)) ->
   Value a -> CodeGenFunction r (Value a)
_fractionLogical :: forall a b r.
(Fraction a, IsPrimitive a, IsInteger b, IsPrimitive b) =>
(FPPredicate -> Value a -> Value a -> CodeGenFunction r (Value b))
-> Value a -> CodeGenFunction r (Value a)
_fractionLogical FPPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
cmp Value a
x =
   do Value a
xf <- Value a -> CodeGenFunction r (Value a)
forall a r. Fraction a => Value a -> CodeGenFunction r (Value a)
signedFraction Value a
x
      Value b
b <- FPPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
cmp FPPredicate
LLVM.FPOLT Value a
xf Value a
forall a. IsType a => Value a
zero
      Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value a
xf (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value b -> CodeGenFunction r (Value a)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp Value b
b

{- |
increment (first operand) may be negative,
phase must always be non-negative
-}
addToPhase ::
   (Fraction a) =>
   Value a -> Value a -> CodeGenFunction r (Value a)
addToPhase :: forall a r.
Fraction a =>
Value a -> Value a -> CodeGenFunction r (Value a)
addToPhase Value a
d Value a
p =
   Value a -> CodeGenFunction r (Value a)
forall r. Value a -> CodeGenFunction r (Value a)
forall a r. Fraction a => Value a -> CodeGenFunction r (Value a)
fraction (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value a
d Value a
p

{- |
both increment and phase must be non-negative
-}
incPhase ::
   (Fraction a) =>
   Value a -> Value a -> CodeGenFunction r (Value a)
incPhase :: forall a r.
Fraction a =>
Value a -> Value a -> CodeGenFunction r (Value a)
incPhase Value a
d Value a
p =
   Value a -> CodeGenFunction r (Value a)
forall a r. Fraction a => Value a -> CodeGenFunction r (Value a)
signedFraction (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value a
d Value a
p



truncateToInt ::
   (IsFloating a, IsInteger i, ShapeOf a ~ ShapeOf i) =>
   Value a -> CodeGenFunction r (Value i)
truncateToInt :: forall a i r.
(IsFloating a, IsInteger i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
truncateToInt = Value a -> CodeGenFunction r (Value i)
forall (value :: * -> *) a b r.
(ValueCons value, IsFloating a, IsInteger b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.fptoint

{- |
Rounds to the next integer.
For numbers of the form @n+0.5@,
we choose one of the neighboured integers
such that the overall implementation is most efficient.
-}
roundToIntFast ::
   (IsFloating a, RationalConstant a, CmpRet a,
    IsInteger i, IntegerConstant i, CmpRet i,
    CmpResult a ~ CmpResult i,
    ShapeOf a ~ ShapeOf i) =>
   Value a -> CodeGenFunction r (Value i)
roundToIntFast :: forall a i r.
(IsFloating a, RationalConstant a, CmpRet a, IsInteger i,
 IntegerConstant i, CmpRet i, CmpResult a ~ CmpResult i,
 ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
roundToIntFast Value a
x = do
   Value (CmpResult i)
pos <- CmpPredicate
-> Value a -> Value a -> CodeGenFunction r (Value (CmpResult i))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpGT Value a
x Value a
forall a. IsType a => Value a
zero
   Value a -> CodeGenFunction r (Value i)
forall a i r.
(IsFloating a, IsInteger i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
truncateToInt (Value a -> CodeGenFunction r (Value i))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value i)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value a
x (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
      Value (CmpResult a)
-> Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
CmpRet a =>
Value (CmpResult a)
-> Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.select Value (CmpResult a)
Value (CmpResult i)
pos (Rational -> Value a
forall a. RationalConstant a => Rational -> Value a
ratio Rational
0.5) (Rational -> Value a
forall a. RationalConstant a => Rational -> Value a
ratio (-Rational
0.5))

floorToInt ::
   (IsFloating a, CmpRet a,
    IsInteger i, IntegerConstant i, CmpRet i,
    CmpResult a ~ CmpResult i,
    ShapeOf a ~ ShapeOf i) =>
   Value a -> CodeGenFunction r (Value i)
floorToInt :: forall a i r.
(IsFloating a, CmpRet a, IsInteger i, IntegerConstant i, CmpRet i,
 CmpResult a ~ CmpResult i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
floorToInt Value a
x = do
   Value i
i <- Value a -> CodeGenFunction r (Value i)
forall a i r.
(IsFloating a, IsInteger i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
truncateToInt Value a
x
   Value (CmpResult i)
lt <- CmpPredicate
-> Value a -> Value a -> CodeGenFunction r (Value (CmpResult i))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpLT Value a
x (Value a -> CodeGenFunction r (Value (CmpResult i)))
-> CodeGenFunction r (Value a)
-> CodeGenFunction r (Value (CmpResult i))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value i -> CodeGenFunction r (Value a)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp Value i
i
   Value i -> Value i -> CodeGenFunction r (Value i)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value i
i (Value i -> CodeGenFunction r (Value i))
-> CodeGenFunction r (Value i) -> CodeGenFunction r (Value i)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (CmpResult i)
-> Value i -> Value i -> CodeGenFunction r (Value i)
forall a r.
CmpRet a =>
Value (CmpResult a)
-> Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.select Value (CmpResult i)
lt (Integer -> Value i
forall a. IntegerConstant a => Integer -> Value a
int Integer
1) (Integer -> Value i
forall a. IntegerConstant a => Integer -> Value a
int Integer
0)

splitFractionToInt ::
   (IsFloating a, CmpRet a,
    IsInteger i, IntegerConstant i, CmpRet i,
    CmpResult a ~ CmpResult i,
    ShapeOf a ~ ShapeOf i) =>
   Value a -> CodeGenFunction r (Value i, Value a)
splitFractionToInt :: forall a i r.
(IsFloating a, CmpRet a, IsInteger i, IntegerConstant i, CmpRet i,
 CmpResult a ~ CmpResult i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i, Value a)
splitFractionToInt Value a
x = do
   Value i
i <- Value a -> CodeGenFunction r (Value i)
forall a i r.
(IsFloating a, CmpRet a, IsInteger i, IntegerConstant i, CmpRet i,
 CmpResult a ~ CmpResult i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
floorToInt Value a
x
   Value a
frac <- Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value a
x (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value i -> CodeGenFunction r (Value a)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp Value i
i
   (Value i, Value a) -> CodeGenFunction r (Value i, Value a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value i
i, Value a
frac)

ceilingToInt ::
   (IsFloating a, CmpRet a,
    IsInteger i, IntegerConstant i, CmpRet i,
    CmpResult a ~ CmpResult i,
    ShapeOf a ~ ShapeOf i) =>
   Value a -> CodeGenFunction r (Value i)
ceilingToInt :: forall a i r.
(IsFloating a, CmpRet a, IsInteger i, IntegerConstant i, CmpRet i,
 CmpResult a ~ CmpResult i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
ceilingToInt Value a
x = do
   Value i
i <- Value a -> CodeGenFunction r (Value i)
forall a i r.
(IsFloating a, IsInteger i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i)
truncateToInt Value a
x
   Value (CmpResult i)
gt <- CmpPredicate
-> Value a -> Value a -> CodeGenFunction r (Value (CmpResult i))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpGT Value a
x (Value a -> CodeGenFunction r (Value (CmpResult i)))
-> CodeGenFunction r (Value a)
-> CodeGenFunction r (Value (CmpResult i))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value i -> CodeGenFunction r (Value a)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp Value i
i
   Value i -> Value i -> CodeGenFunction r (Value i)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value i
i (Value i -> CodeGenFunction r (Value i))
-> CodeGenFunction r (Value i) -> CodeGenFunction r (Value i)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (CmpResult i)
-> Value i -> Value i -> CodeGenFunction r (Value i)
forall a r.
CmpRet a =>
Value (CmpResult a)
-> Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.select Value (CmpResult i)
gt (Integer -> Value i
forall a. IntegerConstant a => Integer -> Value a
int Integer
1) (Integer -> Value i
forall a. IntegerConstant a => Integer -> Value a
int Integer
0)


zero :: (LLVM.IsType a) => Value a
zero :: forall a. IsType a => Value a
zero = ConstValue a -> Value a
forall a. ConstValue a -> Value a
LLVM.value ConstValue a
forall a. IsType a => ConstValue a
LLVM.zero

int :: (IntegerConstant a) => Integer -> Value a
int :: forall a. IntegerConstant a => Integer -> Value a
int = ConstValue a -> Value a
forall a. ConstValue a -> Value a
LLVM.value (ConstValue a -> Value a)
-> (Integer -> ConstValue a) -> Integer -> Value a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ConstValue a
forall a. IntegerConstant a => Integer -> ConstValue a
constFromInteger

ratio :: (RationalConstant a) => Rational -> Value a
ratio :: forall a. RationalConstant a => Rational -> Value a
ratio = ConstValue a -> Value a
forall a. ConstValue a -> Value a
LLVM.value (ConstValue a -> Value a)
-> (Rational -> ConstValue a) -> Rational -> Value a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> ConstValue a
forall a. RationalConstant a => Rational -> ConstValue a
constFromRational



replicateOf ::
   (IsConst (Scalar v), Replicate v) =>
   Scalar v -> Value v
replicateOf :: forall v. (IsConst (Scalar v), Replicate v) => Scalar v -> Value v
replicateOf =
   ConstValue v -> Value v
forall a. ConstValue a -> Value a
LLVM.value (ConstValue v -> Value v)
-> (Scalar v -> ConstValue v) -> Scalar v -> Value v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConstValue (Scalar v) -> ConstValue v
forall vector.
Replicate vector =>
ConstValue (Scalar vector) -> ConstValue vector
replicateConst (ConstValue (Scalar v) -> ConstValue v)
-> (Scalar v -> ConstValue (Scalar v)) -> Scalar v -> ConstValue v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scalar v -> ConstValue (Scalar v)
forall a. IsConst a => a -> ConstValue a
LLVM.constOf


class (LLVM.IsArithmetic a) => Real a where
   min :: Value a -> Value a -> CodeGenFunction r (Value a)
   max :: Value a -> Value a -> CodeGenFunction r (Value a)
   abs :: Value a -> CodeGenFunction r (Value a)
   signum :: Value a -> CodeGenFunction r (Value a)


instance Real Float  where
   min :: forall r.
Value Float -> Value Float -> CodeGenFunction r (Value Float)
min = Value Float -> Value Float -> CodeGenFunction r (Value Float)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.min
   max :: forall r.
Value Float -> Value Float -> CodeGenFunction r (Value Float)
max = Value Float -> Value Float -> CodeGenFunction r (Value Float)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.max
   abs :: forall r. Value Float -> CodeGenFunction r (Value Float)
abs = Value Float -> CodeGenFunction r (Value Float)
forall a r.
IsArithmetic a =>
Value a -> CodeGenFunction r (Value a)
Intrinsic.abs
   signum :: forall r. Value Float -> CodeGenFunction r (Value Float)
signum = Value Float -> CodeGenFunction r (Value Float)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum

instance Real Double where
   min :: forall r.
Value Double -> Value Double -> CodeGenFunction r (Value Double)
min = Value Double -> Value Double -> CodeGenFunction r (Value Double)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.min
   max :: forall r.
Value Double -> Value Double -> CodeGenFunction r (Value Double)
max = Value Double -> Value Double -> CodeGenFunction r (Value Double)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.max
   abs :: forall r. Value Double -> CodeGenFunction r (Value Double)
abs = Value Double -> CodeGenFunction r (Value Double)
forall a r.
IsArithmetic a =>
Value a -> CodeGenFunction r (Value a)
Intrinsic.abs
   signum :: forall r. Value Double -> CodeGenFunction r (Value Double)
signum = Value Double -> CodeGenFunction r (Value Double)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum

instance Real FP128  where
   min :: forall r.
Value FP128 -> Value FP128 -> CodeGenFunction r (Value FP128)
min = Value FP128 -> Value FP128 -> CodeGenFunction r (Value FP128)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.min
   max :: forall r.
Value FP128 -> Value FP128 -> CodeGenFunction r (Value FP128)
max = Value FP128 -> Value FP128 -> CodeGenFunction r (Value FP128)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.max
   abs :: forall r. Value FP128 -> CodeGenFunction r (Value FP128)
abs = Value FP128 -> CodeGenFunction r (Value FP128)
forall a r.
IsArithmetic a =>
Value a -> CodeGenFunction r (Value a)
Intrinsic.abs
   signum :: forall r. Value FP128 -> CodeGenFunction r (Value FP128)
signum Value FP128
x = do
      Value FP128
minusOne <- Value Int8 -> CodeGenFunction r (Value FP128)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp (Value Int8 -> CodeGenFunction r (Value FP128))
-> Value Int8 -> CodeGenFunction r (Value FP128)
forall a b. (a -> b) -> a -> b
$ Int8 -> Value Int8
forall a. IsConst a => a -> Value a
LLVM.valueOf (-Int8
1 :: Int8)
      Value FP128
one      <- Value Int8 -> CodeGenFunction r (Value FP128)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp (Value Int8 -> CodeGenFunction r (Value FP128))
-> Value Int8 -> CodeGenFunction r (Value FP128)
forall a b. (a -> b) -> a -> b
$ Int8 -> Value Int8
forall a. IsConst a => a -> Value a
LLVM.valueOf ( Int8
1 :: Int8)
      Value FP128
-> Value FP128 -> Value FP128 -> CodeGenFunction r (Value FP128)
forall a r.
(CmpRet a, IsPrimitive a) =>
Value a -> Value a -> Value a -> CodeGenFunction r (Value a)
A.signumGen Value FP128
minusOne Value FP128
one Value FP128
x


instance Real Int    where min :: forall r. Value Int -> Value Int -> CodeGenFunction r (Value Int)
min = Value Int -> Value Int -> CodeGenFunction r (Value Int)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r. Value Int -> Value Int -> CodeGenFunction r (Value Int)
max = Value Int -> Value Int -> CodeGenFunction r (Value Int)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Int -> CodeGenFunction r (Value Int)
signum = Value Int -> CodeGenFunction r (Value Int)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Int -> CodeGenFunction r (Value Int)
abs = Value Int -> CodeGenFunction r (Value Int)
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs;
instance Real Int8   where min :: forall r.
Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
min = Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
max = Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Int8 -> CodeGenFunction r (Value Int8)
signum = Value Int8 -> CodeGenFunction r (Value Int8)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Int8 -> CodeGenFunction r (Value Int8)
abs = Value Int8 -> CodeGenFunction r (Value Int8)
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs;
instance Real Int16  where min :: forall r.
Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
min = Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
max = Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Int16 -> CodeGenFunction r (Value Int16)
signum = Value Int16 -> CodeGenFunction r (Value Int16)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Int16 -> CodeGenFunction r (Value Int16)
abs = Value Int16 -> CodeGenFunction r (Value Int16)
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs;
instance Real Int32  where min :: forall r.
Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
min = Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
max = Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Int32 -> CodeGenFunction r (Value Int32)
signum = Value Int32 -> CodeGenFunction r (Value Int32)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Int32 -> CodeGenFunction r (Value Int32)
abs = Value Int32 -> CodeGenFunction r (Value Int32)
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs;
instance Real Int64  where min :: forall r.
Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
min = Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
max = Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Int64 -> CodeGenFunction r (Value Int64)
signum = Value Int64 -> CodeGenFunction r (Value Int64)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Int64 -> CodeGenFunction r (Value Int64)
abs = Value Int64 -> CodeGenFunction r (Value Int64)
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs;
instance Real Word   where min :: forall r.
Value Word -> Value Word -> CodeGenFunction r (Value Word)
min = Value Word -> Value Word -> CodeGenFunction r (Value Word)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Word -> Value Word -> CodeGenFunction r (Value Word)
max = Value Word -> Value Word -> CodeGenFunction r (Value Word)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Word -> CodeGenFunction r (Value Word)
signum = Value Word -> CodeGenFunction r (Value Word)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Word -> CodeGenFunction r (Value Word)
abs = Value Word -> CodeGenFunction r (Value Word)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return;
instance Real Word8  where min :: forall r.
Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
min = Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
max = Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Word8 -> CodeGenFunction r (Value Word8)
signum = Value Word8 -> CodeGenFunction r (Value Word8)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Word8 -> CodeGenFunction r (Value Word8)
abs = Value Word8 -> CodeGenFunction r (Value Word8)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return;
instance Real Word16 where min :: forall r.
Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
min = Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
max = Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Word16 -> CodeGenFunction r (Value Word16)
signum = Value Word16 -> CodeGenFunction r (Value Word16)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Word16 -> CodeGenFunction r (Value Word16)
abs = Value Word16 -> CodeGenFunction r (Value Word16)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return;
instance Real Word32 where min :: forall r.
Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
min = Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
max = Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Word32 -> CodeGenFunction r (Value Word32)
signum = Value Word32 -> CodeGenFunction r (Value Word32)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Word32 -> CodeGenFunction r (Value Word32)
abs = Value Word32 -> CodeGenFunction r (Value Word32)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return;
instance Real Word64 where min :: forall r.
Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
min = Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
max = Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; signum :: forall r. Value Word64 -> CodeGenFunction r (Value Word64)
signum = Value Word64 -> CodeGenFunction r (Value Word64)
forall a r.
(Num a, CmpRet a, IsConst a, IsPrimitive a) =>
Value a -> CodeGenFunction r (Value a)
A.signum; abs :: forall r. Value Word64 -> CodeGenFunction r (Value Word64)
abs = Value Word64 -> CodeGenFunction r (Value Word64)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return;

instance (TypeNum.Positive n) => Real (IntN n) where
   min :: forall r.
Value (IntN n)
-> Value (IntN n) -> CodeGenFunction r (Value (IntN n))
min = Value (IntN n)
-> Value (IntN n) -> CodeGenFunction r (Value (IntN n))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value (IntN n)
-> Value (IntN n) -> CodeGenFunction r (Value (IntN n))
max = Value (IntN n)
-> Value (IntN n) -> CodeGenFunction r (Value (IntN n))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; abs :: forall r. Value (IntN n) -> CodeGenFunction r (Value (IntN n))
abs = Value (IntN n) -> CodeGenFunction r (Value (IntN n))
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs
   signum :: forall r. Value (IntN n) -> CodeGenFunction r (Value (IntN n))
signum = Value (IntN n)
-> Value (IntN n)
-> Value (IntN n)
-> CodeGenFunction r (Value (IntN n))
forall a r.
(CmpRet a, IsPrimitive a) =>
Value a -> Value a -> Value a -> CodeGenFunction r (Value a)
A.signumGen (IntN n -> Value (IntN n)
forall a. IsConst a => a -> Value a
LLVM.valueOf (IntN n -> Value (IntN n)) -> IntN n -> Value (IntN n)
forall a b. (a -> b) -> a -> b
$ Integer -> IntN n
forall n. Integer -> IntN n
IntN (-Integer
1)) (IntN n -> Value (IntN n)
forall a. IsConst a => a -> Value a
LLVM.valueOf (IntN n -> Value (IntN n)) -> IntN n -> Value (IntN n)
forall a b. (a -> b) -> a -> b
$ Integer -> IntN n
forall n. Integer -> IntN n
IntN Integer
1)
instance (TypeNum.Positive n) => Real (WordN n) where
   min :: forall r.
Value (WordN n)
-> Value (WordN n) -> CodeGenFunction r (Value (WordN n))
min = Value (WordN n)
-> Value (WordN n) -> CodeGenFunction r (Value (WordN n))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min; max :: forall r.
Value (WordN n)
-> Value (WordN n) -> CodeGenFunction r (Value (WordN n))
max = Value (WordN n)
-> Value (WordN n) -> CodeGenFunction r (Value (WordN n))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max; abs :: forall r. Value (WordN n) -> CodeGenFunction r (Value (WordN n))
abs = Value (WordN n) -> CodeGenFunction r (Value (WordN n))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
   signum :: forall r. Value (WordN n) -> CodeGenFunction r (Value (WordN n))
signum = Value (WordN n)
-> Value (WordN n)
-> Value (WordN n)
-> CodeGenFunction r (Value (WordN n))
forall a r.
(CmpRet a, IsPrimitive a) =>
Value a -> Value a -> Value a -> CodeGenFunction r (Value a)
A.signumGen (ConstValue (WordN n) -> Value (WordN n)
forall a. ConstValue a -> Value a
LLVM.value ConstValue (WordN n)
forall a. IsType a => ConstValue a
LLVM.undef) (WordN n -> Value (WordN n)
forall a. IsConst a => a -> Value a
LLVM.valueOf (WordN n -> Value (WordN n)) -> WordN n -> Value (WordN n)
forall a b. (a -> b) -> a -> b
$ Integer -> WordN n
forall n. Integer -> WordN n
WordN Integer
1)

instance (TypeNum.Positive n, Vector.Real a) => Real (Vector n a) where
   min :: forall r.
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
min = Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
Vector.min
   max :: forall r.
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
max = Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
Vector.max
   abs :: forall r.
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
abs = Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
Vector.abs
   signum :: forall r.
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signum = Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
Vector.signum


class (IsInteger a) => Saturated a where
   addSat, subSat :: Value a -> Value a -> CodeGenFunction r (Value a)

instance Saturated Int    where
   addSat :: forall r. Value Int -> Value Int -> CodeGenFunction r (Value Int)
addSat = Proxy Int
-> Value Int -> Value Int -> CodeGenFunction r (Value Int)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Int
forall a. Proxy a
LP.Proxy; subSat :: forall r. Value Int -> Value Int -> CodeGenFunction r (Value Int)
subSat = Proxy Int
-> Value Int -> Value Int -> CodeGenFunction r (Value Int)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Int
forall a. Proxy a
LP.Proxy;
instance Saturated Int8   where
   addSat :: forall r.
Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
addSat = Proxy Int8
-> Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Int8
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
subSat = Proxy Int8
-> Value Int8 -> Value Int8 -> CodeGenFunction r (Value Int8)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Int8
forall a. Proxy a
LP.Proxy;
instance Saturated Int16  where
   addSat :: forall r.
Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
addSat = Proxy Int16
-> Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Int16
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
subSat = Proxy Int16
-> Value Int16 -> Value Int16 -> CodeGenFunction r (Value Int16)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Int16
forall a. Proxy a
LP.Proxy;
instance Saturated Int32  where
   addSat :: forall r.
Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
addSat = Proxy Int32
-> Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Int32
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
subSat = Proxy Int32
-> Value Int32 -> Value Int32 -> CodeGenFunction r (Value Int32)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Int32
forall a. Proxy a
LP.Proxy;
instance Saturated Int64  where
   addSat :: forall r.
Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
addSat = Proxy Int64
-> Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Int64
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
subSat = Proxy Int64
-> Value Int64 -> Value Int64 -> CodeGenFunction r (Value Int64)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Int64
forall a. Proxy a
LP.Proxy;
instance Saturated Word   where
   addSat :: forall r.
Value Word -> Value Word -> CodeGenFunction r (Value Word)
addSat = Proxy Word
-> Value Word -> Value Word -> CodeGenFunction r (Value Word)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Word
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Word -> Value Word -> CodeGenFunction r (Value Word)
subSat = Proxy Word
-> Value Word -> Value Word -> CodeGenFunction r (Value Word)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Word
forall a. Proxy a
LP.Proxy;
instance Saturated Word8  where
   addSat :: forall r.
Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
addSat = Proxy Word8
-> Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Word8
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
subSat = Proxy Word8
-> Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Word8
forall a. Proxy a
LP.Proxy;
instance Saturated Word16 where
   addSat :: forall r.
Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
addSat = Proxy Word16
-> Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Word16
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
subSat = Proxy Word16
-> Value Word16 -> Value Word16 -> CodeGenFunction r (Value Word16)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Word16
forall a. Proxy a
LP.Proxy;
instance Saturated Word32 where
   addSat :: forall r.
Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
addSat = Proxy Word32
-> Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Word32
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
subSat = Proxy Word32
-> Value Word32 -> Value Word32 -> CodeGenFunction r (Value Word32)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Word32
forall a. Proxy a
LP.Proxy;
instance Saturated Word64 where
   addSat :: forall r.
Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
addSat = Proxy Word64
-> Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy Word64
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
subSat = Proxy Word64
-> Value Word64 -> Value Word64 -> CodeGenFunction r (Value Word64)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy Word64
forall a. Proxy a
LP.Proxy;
instance (TypeNum.Positive d) => Saturated (IntN  d) where
   addSat :: forall r.
Value (IntN d)
-> Value (IntN d) -> CodeGenFunction r (Value (IntN d))
addSat = Proxy (IntN d)
-> Value (IntN d)
-> Value (IntN d)
-> CodeGenFunction r (Value (IntN d))
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy (IntN d)
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value (IntN d)
-> Value (IntN d) -> CodeGenFunction r (Value (IntN d))
subSat = Proxy (IntN d)
-> Value (IntN d)
-> Value (IntN d)
-> CodeGenFunction r (Value (IntN d))
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy (IntN d)
forall a. Proxy a
LP.Proxy;
instance (TypeNum.Positive d) => Saturated (WordN d) where
   addSat :: forall r.
Value (WordN d)
-> Value (WordN d) -> CodeGenFunction r (Value (WordN d))
addSat = Proxy (WordN d)
-> Value (WordN d)
-> Value (WordN d)
-> CodeGenFunction r (Value (WordN d))
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy (WordN d)
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value (WordN d)
-> Value (WordN d) -> CodeGenFunction r (Value (WordN d))
subSat = Proxy (WordN d)
-> Value (WordN d)
-> Value (WordN d)
-> CodeGenFunction r (Value (WordN d))
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy (WordN d)
forall a. Proxy a
LP.Proxy;
instance
   (TypeNum.Positive n, LLVM.IsPrimitive a,
    Saturated a, Bounded a, CmpRet a, IsConst a) =>
      Saturated (Vector n a) where
   addSat :: forall r.
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
addSat = Proxy (Vector n a)
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n a))
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy (Vector n a)
forall a. Proxy a
LP.Proxy; subSat :: forall r.
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
subSat = Proxy (Vector n a)
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n a))
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy (Vector n a)
forall a. Proxy a
LP.Proxy;

addSatProxy, subSatProxy ::
   (IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
    LLVM.ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
    Scalar v ~ a, IsConst a, Bounded a) =>
   LP.Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy :: forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
addSatProxy Proxy v
proxy =
   if Proxy v -> Bool
forall a. IsArithmetic a => Proxy a -> Bool
LLVM.isSigned Proxy v
proxy
      then (Value v -> Value v -> CodeGenFunction r (Value v))
-> Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
-> Value v
-> Value v
-> CodeGenFunction r (Value v)
forall a. a -> Maybe a -> a
fromMaybe Value v -> Value v -> CodeGenFunction r (Value v)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Value v -> Value v -> CodeGenFunction r (Value v)
Priv.saddSat Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
forall a r.
IsInteger a =>
Maybe (Value a -> Value a -> CodeGenFunction r (Value a))
Intrinsic.maybeSAddSat
      else (Value v -> Value v -> CodeGenFunction r (Value v))
-> Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
-> Value v
-> Value v
-> CodeGenFunction r (Value v)
forall a. a -> Maybe a -> a
fromMaybe Value v -> Value v -> CodeGenFunction r (Value v)
forall v a r.
(IsInteger v, CmpRet v, Replicate v, Scalar v ~ a, IsConst a,
 Bounded a) =>
Value v -> Value v -> CodeGenFunction r (Value v)
Priv.uaddSat Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
forall a r.
IsInteger a =>
Maybe (Value a -> Value a -> CodeGenFunction r (Value a))
Intrinsic.maybeUAddSat
subSatProxy :: forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Proxy v -> Value v -> Value v -> CodeGenFunction r (Value v)
subSatProxy Proxy v
proxy =
   if Proxy v -> Bool
forall a. IsArithmetic a => Proxy a -> Bool
LLVM.isSigned Proxy v
proxy
      then (Value v -> Value v -> CodeGenFunction r (Value v))
-> Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
-> Value v
-> Value v
-> CodeGenFunction r (Value v)
forall a. a -> Maybe a -> a
fromMaybe Value v -> Value v -> CodeGenFunction r (Value v)
forall v shape bv a r.
(IsInteger v, CmpRet v, Replicate v, ShapeOf v ~ shape,
 ShapedType shape Bool ~ bv, ShapeOf bv ~ shape, CmpRet bv,
 Scalar v ~ a, IsConst a, Bounded a) =>
Value v -> Value v -> CodeGenFunction r (Value v)
Priv.ssubSat Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
forall a r.
IsInteger a =>
Maybe (Value a -> Value a -> CodeGenFunction r (Value a))
Intrinsic.maybeSSubSat
      else (Value v -> Value v -> CodeGenFunction r (Value v))
-> Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
-> Value v
-> Value v
-> CodeGenFunction r (Value v)
forall a. a -> Maybe a -> a
fromMaybe Value v -> Value v -> CodeGenFunction r (Value v)
forall v a r.
(IsInteger v, CmpRet v, Replicate v, Scalar v ~ a, IsConst a,
 Bounded a) =>
Value v -> Value v -> CodeGenFunction r (Value v)
Priv.usubSat Maybe (Value v -> Value v -> CodeGenFunction r (Value v))
forall a r.
IsInteger a =>
Maybe (Value a -> Value a -> CodeGenFunction r (Value a))
Intrinsic.maybeUSubSat



class
   (LLVM.IsArithmetic (Scalar v), LLVM.IsArithmetic v) =>
      PseudoModule v where
   scale :: (a ~ Scalar v) => Value a -> Value v -> CodeGenFunction r (Value v)

instance PseudoModule Word   where scale :: forall a r.
(a ~ Scalar Word) =>
Value a -> Value Word -> CodeGenFunction r (Value Word)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Word -> CodeGenFunction r (Value Word)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Word8  where scale :: forall a r.
(a ~ Scalar Word8) =>
Value a -> Value Word8 -> CodeGenFunction r (Value Word8)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Word8 -> CodeGenFunction r (Value Word8)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Word16 where scale :: forall a r.
(a ~ Scalar Word16) =>
Value a -> Value Word16 -> CodeGenFunction r (Value Word16)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Word16 -> CodeGenFunction r (Value Word16)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Word32 where scale :: forall a r.
(a ~ Scalar Word32) =>
Value a -> Value Word32 -> CodeGenFunction r (Value Word32)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Word32 -> CodeGenFunction r (Value Word32)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Word64 where scale :: forall a r.
(a ~ Scalar Word64) =>
Value a -> Value Word64 -> CodeGenFunction r (Value Word64)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Word64 -> CodeGenFunction r (Value Word64)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Int    where scale :: forall a r.
(a ~ Scalar Int) =>
Value a -> Value Int -> CodeGenFunction r (Value Int)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Int -> CodeGenFunction r (Value Int)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Int8   where scale :: forall a r.
(a ~ Scalar Int8) =>
Value a -> Value Int8 -> CodeGenFunction r (Value Int8)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Int8 -> CodeGenFunction r (Value Int8)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Int16  where scale :: forall a r.
(a ~ Scalar Int16) =>
Value a -> Value Int16 -> CodeGenFunction r (Value Int16)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Int16 -> CodeGenFunction r (Value Int16)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Int32  where scale :: forall a r.
(a ~ Scalar Int32) =>
Value a -> Value Int32 -> CodeGenFunction r (Value Int32)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Int32 -> CodeGenFunction r (Value Int32)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Int64  where scale :: forall a r.
(a ~ Scalar Int64) =>
Value a -> Value Int64 -> CodeGenFunction r (Value Int64)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Int64 -> CodeGenFunction r (Value Int64)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Float  where scale :: forall a r.
(a ~ Scalar Float) =>
Value a -> Value Float -> CodeGenFunction r (Value Float)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Float -> CodeGenFunction r (Value Float)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance PseudoModule Double where scale :: forall a r.
(a ~ Scalar Double) =>
Value a -> Value Double -> CodeGenFunction r (Value Double)
scale = Value a -> Value a -> CodeGenFunction r (Value a)
Value a -> Value Double -> CodeGenFunction r (Value Double)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
LLVM.mul
instance (LLVM.IsArithmetic a, LLVM.IsPrimitive a, TypeNum.Positive n) =>
         PseudoModule (Vector n a) where
   scale :: forall a r.
(a ~ Scalar (Vector n a)) =>
Value a
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
scale Value a
a Value (Vector n a)
v = (Value (Vector n a)
 -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n a))
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.mul Value (Vector n a)
v (Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Scalar (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall r.
Value (Scalar (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall vector r.
Replicate vector =>
Value (Scalar vector) -> CodeGenFunction r (Value vector)
replicate Value a
Value (Scalar (Vector n a))
a



class (LLVM.IsConst a) => IntegerConstant a where
   constFromInteger :: Integer -> ConstValue a

instance IntegerConstant Word   where constFromInteger :: Integer -> ConstValue Word
constFromInteger = Word -> ConstValue Word
forall a. IsConst a => a -> ConstValue a
constOf (Word -> ConstValue Word)
-> (Integer -> Word) -> Integer -> ConstValue Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Word8  where constFromInteger :: Integer -> ConstValue Word8
constFromInteger = Word8 -> ConstValue Word8
forall a. IsConst a => a -> ConstValue a
constOf (Word8 -> ConstValue Word8)
-> (Integer -> Word8) -> Integer -> ConstValue Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word8
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Word16 where constFromInteger :: Integer -> ConstValue Word16
constFromInteger = Word16 -> ConstValue Word16
forall a. IsConst a => a -> ConstValue a
constOf (Word16 -> ConstValue Word16)
-> (Integer -> Word16) -> Integer -> ConstValue Word16
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word16
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Word32 where constFromInteger :: Integer -> ConstValue Word32
constFromInteger = Word32 -> ConstValue Word32
forall a. IsConst a => a -> ConstValue a
constOf (Word32 -> ConstValue Word32)
-> (Integer -> Word32) -> Integer -> ConstValue Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word32
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Word64 where constFromInteger :: Integer -> ConstValue Word64
constFromInteger = Word64 -> ConstValue Word64
forall a. IsConst a => a -> ConstValue a
constOf (Word64 -> ConstValue Word64)
-> (Integer -> Word64) -> Integer -> ConstValue Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word64
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Int    where constFromInteger :: Integer -> ConstValue Int
constFromInteger = Int -> ConstValue Int
forall a. IsConst a => a -> ConstValue a
constOf (Int -> ConstValue Int)
-> (Integer -> Int) -> Integer -> ConstValue Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Int8   where constFromInteger :: Integer -> ConstValue Int8
constFromInteger = Int8 -> ConstValue Int8
forall a. IsConst a => a -> ConstValue a
constOf (Int8 -> ConstValue Int8)
-> (Integer -> Int8) -> Integer -> ConstValue Int8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int8
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Int16  where constFromInteger :: Integer -> ConstValue Int16
constFromInteger = Int16 -> ConstValue Int16
forall a. IsConst a => a -> ConstValue a
constOf (Int16 -> ConstValue Int16)
-> (Integer -> Int16) -> Integer -> ConstValue Int16
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int16
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Int32  where constFromInteger :: Integer -> ConstValue Int32
constFromInteger = Int32 -> ConstValue Int32
forall a. IsConst a => a -> ConstValue a
constOf (Int32 -> ConstValue Int32)
-> (Integer -> Int32) -> Integer -> ConstValue Int32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int32
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Int64  where constFromInteger :: Integer -> ConstValue Int64
constFromInteger = Int64 -> ConstValue Int64
forall a. IsConst a => a -> ConstValue a
constOf (Int64 -> ConstValue Int64)
-> (Integer -> Int64) -> Integer -> ConstValue Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int64
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Float  where constFromInteger :: Integer -> ConstValue Float
constFromInteger = Float -> ConstValue Float
forall a. IsConst a => a -> ConstValue a
constOf (Float -> ConstValue Float)
-> (Integer -> Float) -> Integer -> ConstValue Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Float
forall a. Num a => Integer -> a
fromInteger
instance IntegerConstant Double where constFromInteger :: Integer -> ConstValue Double
constFromInteger = Double -> ConstValue Double
forall a. IsConst a => a -> ConstValue a
constOf (Double -> ConstValue Double)
-> (Integer -> Double) -> Integer -> ConstValue Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a. Num a => Integer -> a
fromInteger
instance (TypeNum.Positive n) => IntegerConstant (WordN n) where
   constFromInteger :: Integer -> ConstValue (WordN n)
constFromInteger = WordN n -> ConstValue (WordN n)
forall a. IsConst a => a -> ConstValue a
constOf (WordN n -> ConstValue (WordN n))
-> (Integer -> WordN n) -> Integer -> ConstValue (WordN n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> WordN n
forall n. Integer -> WordN n
WordN
instance (TypeNum.Positive n) => IntegerConstant (IntN n)  where
   constFromInteger :: Integer -> ConstValue (IntN n)
constFromInteger = IntN n -> ConstValue (IntN n)
forall a. IsConst a => a -> ConstValue a
constOf (IntN n -> ConstValue (IntN n))
-> (Integer -> IntN n) -> Integer -> ConstValue (IntN n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> IntN n
forall n. Integer -> IntN n
IntN
instance (IntegerConstant a, LLVM.IsPrimitive a, TypeNum.Positive n) =>
         IntegerConstant (Vector n a) where
   constFromInteger :: Integer -> ConstValue (Vector n a)
constFromInteger = ConstValue a -> ConstValue (Vector n a)
ConstValue (Scalar (Vector n a)) -> ConstValue (Vector n a)
forall vector.
Replicate vector =>
ConstValue (Scalar vector) -> ConstValue vector
replicateConst (ConstValue a -> ConstValue (Vector n a))
-> (Integer -> ConstValue a) -> Integer -> ConstValue (Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ConstValue a
forall a. IntegerConstant a => Integer -> ConstValue a
constFromInteger


class (IntegerConstant a) => RationalConstant a where
   constFromRational :: Rational -> ConstValue a

instance RationalConstant Float  where constFromRational :: Rational -> ConstValue Float
constFromRational = Float -> ConstValue Float
forall a. IsConst a => a -> ConstValue a
constOf (Float -> ConstValue Float)
-> (Rational -> Float) -> Rational -> ConstValue Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Float
forall a. Fractional a => Rational -> a
fromRational
instance RationalConstant Double where constFromRational :: Rational -> ConstValue Double
constFromRational = Double -> ConstValue Double
forall a. IsConst a => a -> ConstValue a
constOf (Double -> ConstValue Double)
-> (Rational -> Double) -> Rational -> ConstValue Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational
instance (RationalConstant a, LLVM.IsPrimitive a, TypeNum.Positive n) =>
         RationalConstant (Vector n a) where
   constFromRational :: Rational -> ConstValue (Vector n a)
constFromRational = ConstValue a -> ConstValue (Vector n a)
ConstValue (Scalar (Vector n a)) -> ConstValue (Vector n a)
forall vector.
Replicate vector =>
ConstValue (Scalar vector) -> ConstValue vector
replicateConst (ConstValue a -> ConstValue (Vector n a))
-> (Rational -> ConstValue a)
-> Rational
-> ConstValue (Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> ConstValue a
forall a. RationalConstant a => Rational -> ConstValue a
constFromRational


class (RationalConstant a) => TranscendentalConstant a where
   constPi :: ConstValue a

instance TranscendentalConstant Float  where constPi :: ConstValue Float
constPi = Float -> ConstValue Float
forall a. IsConst a => a -> ConstValue a
constOf Float
forall a. Floating a => a
pi
instance TranscendentalConstant Double where constPi :: ConstValue Double
constPi = Double -> ConstValue Double
forall a. IsConst a => a -> ConstValue a
constOf Double
forall a. Floating a => a
pi
instance (TranscendentalConstant a, LLVM.IsPrimitive a, TypeNum.Positive n) =>
         TranscendentalConstant (Vector n a) where
   constPi :: ConstValue (Vector n a)
constPi = ConstValue (Scalar (Vector n a)) -> ConstValue (Vector n a)
forall vector.
Replicate vector =>
ConstValue (Scalar vector) -> ConstValue vector
replicateConst ConstValue a
ConstValue (Scalar (Vector n a))
forall a. TranscendentalConstant a => ConstValue a
constPi