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)

(Flags flags, Tuple a, Additive a) => Additive (Context flags 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)

(Flags flags, PseudoRing a, Tuple a) => PseudoRing (Context flags 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)

PseudoRing a => PseudoModule (T a)

PseudoModule a => PseudoModule (T a)

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

(Flags flags, PseudoModule v, Tuple v, ~ * (Scalar v) a, Tuple a) => PseudoModule (Context flags 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)

Field a => Field (T a)

Field a => Field (T a)

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

(Flags flags, Tuple v, Field v) => Field (Context flags v)

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)

(Flags flags, Tuple a, IntegerConstant a) => IntegerConstant (Context flags 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)

(Flags flags, Tuple a, RationalConstant a) => RationalConstant (Context flags 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)

(Flags flags, Tuple a, FloatingComparison a) => FloatingComparison (Context flags 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)

(Flags flags, Tuple a, Comparison a) => Comparison (Context flags a)

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

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)

(Flags flags, Tuple a, Real a) => Real (Context flags 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)

(Flags flags, Tuple a, Fraction a) => Fraction (Context flags 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)

(Flags flags, Tuple a, Algebraic a) => Algebraic (Context flags 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)

(Flags flags, Tuple a, Transcendental a) => Transcendental (Context flags a)