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 (T a)

Additive a => Additive (T a)

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

(Positive n, Additive a) => Additive (T n a)

(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)

PseudoRing a => PseudoRing (T a)

PseudoRing a => PseudoRing (T a)

(Positive n, PseudoRing a) => PseudoRing (T n a)

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

type family Scalar vector :: *

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

Methods

scale :: Scalar v -> v -> CodeGenFunction r v

Instances

PseudoModule v => PseudoModule (Value v)

PseudoModule v => PseudoModule (ConstValue v)

PseudoModule a => PseudoModule (T a)

PseudoRing a => PseudoModule (T a)

(Positive n, PseudoModule a) => PseudoModule (T n a)

class PseudoRing a => Field a where

Methods

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

Instances

IsFloating v => Field (Value v)

IsFloating v => Field (ConstValue v)

Field a => Field (T a)

Field a => Field (T a)

(Positive n, Field a) => Field (T n a)

class IntegerConstant a where

Methods

fromInteger' :: Integer -> a

Instances

IntegerConstant a => IntegerConstant (Value a)

IntegerConstant a => IntegerConstant (ConstValue a)

IntegerConstant a => IntegerConstant (T a)

IntegerConstant a => IntegerConstant (T a)

(Positive n, IntegerConstant a) => IntegerConstant (T n a)

class IntegerConstant a => RationalConstant a where

Methods

fromRational' :: Rational -> a

Instances

RationalConstant a => RationalConstant (Value a)

RationalConstant a => RationalConstant (ConstValue a)

RationalConstant a => RationalConstant (T a)

RationalConstant a => RationalConstant (T a)

(Positive n, RationalConstant a) => RationalConstant (T n a)

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

In Haskell terms this is a quot.

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

class Comparison a => FloatingComparison a where

Methods

fcmp :: FPPredicate -> a -> a -> CodeGenFunction r (CmpResult a)

Instances

(IsFloating a, CmpRet a) => FloatingComparison (Value a)

(IsFloating a, CmpRet a) => FloatingComparison (ConstValue a)

FloatingComparison a => FloatingComparison (T a)

(Positive n, FloatingComparison a) => FloatingComparison (T n a)

class Comparison a where

Associated Types

type CmpResult a :: *

Methods

cmp :: CmpPredicate -> a -> a -> CodeGenFunction r (CmpResult a)

Instances

CmpRet a => Comparison (Value a)

CmpRet a => Comparison (ConstValue a)

Comparison a => Comparison (T a)

(Positive n, Comparison a) => Comparison (T n a)

data CmpPredicate

Constructors

CmpEQ

CmpNE

CmpGT

CmpGE

CmpLT

CmpLE

Instances

Enum CmpPredicate

Eq CmpPredicate

Ord CmpPredicate

Show CmpPredicate

Typeable CmpPredicate

class Logic a where

Methods

and :: a -> a -> CodeGenFunction r a

or :: a -> a -> CodeGenFunction r a

xor :: a -> a -> CodeGenFunction r a

inv :: a -> CodeGenFunction r a

Instances

IsInteger a => Logic (Value a)

IsInteger a => Logic (ConstValue a)

Logic a => Logic (T a)

(Positive n, Logic a) => Logic (T n 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)

Real a => Real (T a)

Real a => Real (T a)

(Positive n, Real a) => Real (T n a)

class Real a => Fraction a where

Methods

truncate :: a -> CodeGenFunction r a

fraction :: a -> CodeGenFunction r a

Instances

Fraction a => Fraction (Value a)

Fraction a => Fraction (T a)

Fraction a => Fraction (T a)

(Positive n, Fraction a) => Fraction (T n 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))

decreaseArrayElementPtr :: 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)

Algebraic a => Algebraic (T a)

Algebraic a => Algebraic (T a)

(Positive n, Algebraic a) => Algebraic (T n 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)

Transcendental a => Transcendental (T a)

Transcendental a => Transcendental (T a)

(Positive n, Transcendental a) => Transcendental (T n a)