LLVM.Extra.Arithmetic

arithmetic: generalized and improved type inference

class Zero a => Additive a where

This and the following type classes are intended for arithmetic operations on wrappers around LLVM types. E.g. you might define a fixed point fraction type by

 newtype Fixed = Fixed Int32

and then use the same methods for floating point and fixed point arithmetic.

In contrast to the arithmetic methods in the llvm wrapper, in our methods the types of operands and result match. Advantage: Type inference determines most of the types automatically. Disadvantage: You cannot use constant values directly, but you have to convert them all to Value.

Methods

zero :: a

add :: a -> a -> CodeGenFunction r a

sub :: a -> a -> CodeGenFunction r a

neg :: a -> CodeGenFunction r a

Instances

IsArithmetic a => Additive (Value a)

IsArithmetic a => Additive (ConstValue a)

(Additive a, Additive b) => Additive (a, b)

(Additive a, Additive b, Additive c) => Additive (a, b, c)

one :: IntegerConstant a => a

inc :: (IsArithmetic a, IsConst a, Num a) => Value a -> CodeGenFunction r (Value a)

dec :: (IsArithmetic a, IsConst a, Num a) => Value a -> CodeGenFunction r (Value a)

class Additive a => PseudoRing a where

Methods

mul :: a -> a -> CodeGenFunction r a

Instances

IsArithmetic v => PseudoRing (Value v)

IsArithmetic v => PseudoRing (ConstValue v)

square :: PseudoRing a => a -> CodeGenFunction r a

class (PseudoRing a, Additive v) => PseudoModule a v where

Methods

scale :: a -> v -> CodeGenFunction r v

Instances

PseudoModule a v => PseudoModule (Value a) (Value v)

PseudoModule a v => PseudoModule (ConstValue a) (ConstValue v)

class PseudoRing a => Field a where

Methods

fdiv :: a -> a -> CodeGenFunction r a

Instances

IsFloating v => Field (Value v)

IsFloating v => Field (ConstValue v)

class IntegerConstant a where

Methods

fromInteger' :: Integer -> a

Instances

IntegerConstant a => IntegerConstant (Value a)

IntegerConstant a => IntegerConstant (ConstValue a)

class IntegerConstant a => RationalConstant a where

Methods

fromRational' :: Rational -> a

Instances

RationalConstant a => RationalConstant (Value a)

RationalConstant a => RationalConstant (ConstValue a)

idiv :: IsInteger a => Value a -> Value a -> CodeGenFunction r (Value a)

irem :: IsInteger a => Value a -> Value a -> CodeGenFunction r (Value a)

fcmp :: (IsFloating a, CmpRet a, CmpResult a ~ b) => FPPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)

cmp :: (CmpRet a, CmpResult a ~ b) => CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)

data CmpPredicate

Constructors

CmpEQ

equal

CmpNE

not equal

CmpGT

greater than

CmpGE

greater or equal

CmpLT

less than

CmpLE

less or equal

Instances

Enum CmpPredicate

Eq CmpPredicate

Ord CmpPredicate

Show CmpPredicate

Typeable CmpPredicate

and :: IsInteger a => Value a -> Value a -> CodeGenFunction r (Value a)

or :: IsInteger a => Value a -> Value a -> CodeGenFunction r (Value a)

class Additive a => Real a where

Methods

min :: a -> a -> CodeGenFunction r a

max :: a -> a -> CodeGenFunction r a

abs :: a -> CodeGenFunction r a

signum :: a -> CodeGenFunction r a

Instances

Real a => Real (Value a)

class Real a => Fraction a where

Methods

truncate :: a -> CodeGenFunction r a

fraction :: a -> CodeGenFunction r a

Instances

Fraction a => Fraction (Value a)

signedFraction :: Fraction a => a -> CodeGenFunction r a

addToPhase :: Fraction a => a -> a -> CodeGenFunction r a

incPhase :: Fraction a => a -> a -> CodeGenFunction r a

both increment and phase must be non-negative

pointer arithmetic

advanceArrayElementPtr :: Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))

transcendental functions

class Field a => Algebraic a where

Methods

sqrt :: a -> CodeGenFunction r a

Instances

IsFloating a => Algebraic (Value a)

class Algebraic a => Transcendental a where

Methods

pi :: CodeGenFunction r a

sin, log, exp, cos :: a -> CodeGenFunction r a

pow :: a -> a -> CodeGenFunction r a

Instances

(IsFloating a, TranscendentalConstant a) => Transcendental (Value a)