Language.Atom.Expressions

Types

data E a where

A typed expression.

Constructors

VRef :: V a -> E a

Const :: a -> E a

Cast :: (NumE a, NumE b) => E a -> E b

Add :: NumE a => E a -> E a -> E a

Sub :: NumE a => E a -> E a -> E a

Mul :: NumE a => E a -> E a -> E a

Div :: NumE a => E a -> E a -> E a

Mod :: IntegralE a => E a -> E a -> E a

Not :: E Bool -> E Bool

And :: E Bool -> E Bool -> E Bool

BWNot :: IntegralE a => E a -> E a

BWAnd :: IntegralE a => E a -> E a -> E a

BWOr :: IntegralE a => E a -> E a -> E a

BWXor :: IntegralE a => E a -> E a -> E a

BWShiftL :: (IntegralE a, IntegralE b) => E a -> E b -> E a

BWShiftR :: (IntegralE a, IntegralE b) => E a -> E b -> E a

Eq :: EqE a => E a -> E a -> E Bool

Lt :: OrdE a => E a -> E a -> E Bool

Mux :: E Bool -> E a -> E a -> E a

F2B :: E Float -> E Word32

D2B :: E Double -> E Word64

B2F :: E Word32 -> E Float

B2D :: E Word64 -> E Double

Retype :: UE -> E a

Pi :: FloatingE a => E a

Exp :: FloatingE a => E a -> E a

Log :: FloatingE a => E a -> E a

Sqrt :: FloatingE a => E a -> E a

Pow :: FloatingE a => E a -> E a -> E a

Sin :: FloatingE a => E a -> E a

Asin :: FloatingE a => E a -> E a

Cos :: FloatingE a => E a -> E a

Acos :: FloatingE a => E a -> E a

Sinh :: FloatingE a => E a -> E a

Cosh :: FloatingE a => E a -> E a

Asinh :: FloatingE a => E a -> E a

Acosh :: FloatingE a => E a -> E a

Atan :: FloatingE a => E a -> E a

Atanh :: FloatingE a => E a -> E a

Instances

Expr a => Eq (E a)

(Num a, Fractional a, Floating a, FloatingE a) => Floating (E a)

(OrdE a, NumE a, Num a, Fractional a) => Fractional (E a)

(Num a, NumE a, OrdE a) => Num (E a)

Show (E a)

(Expr a, OrdE a, EqE a, IntegralE a, Bits a) => Bits (E a)

Expr a => TypeOf (E a)

Expr a => Width (E a)

data V a

Variables updated by state transition rules.

Constructors

V UV

Instances

Eq (V a)

TypeOf (V a)

Expr a => Width (V a)

data UE

An untyped term.

Constructors

UVRef UV

UConst Const

UCast Type UE

UAdd UE UE

USub UE UE

UMul UE UE

UDiv UE UE

UMod UE UE

UNot UE

UAnd [UE]

UBWNot UE

UBWAnd UE UE

UBWOr UE UE

UBWXor UE UE

UBWShiftL UE UE

UBWShiftR UE UE

UEq UE UE

ULt UE UE

UMux UE UE UE

UF2B UE

UD2B UE

UB2F UE

UB2D UE

UPi

UExp UE

ULog UE

USqrt UE

UPow UE UE

USin UE

UAsin UE

UCos UE

UAcos UE

USinh UE

UCosh UE

UAsinh UE

UAcosh UE

UAtan UE

UAtanh UE

Instances

Eq UE

Data UE

Ord UE

Show UE

Typeable UE

TypeOf UE

Width UE

data UV

Untyped variables.

Constructors

UV Int String Const

UVArray UA UE

UVExtern String Type

Instances

Eq UV

Data UV

Ord UV

Show UV

Typeable UV

TypeOf UV

Width UV

data A a

A typed array.

Constructors

A UA

Instances

Eq (A a)

TypeOf (A a)

data UA

An untyped array.

Constructors

UA Int String [Const]

UAExtern String Type

Instances

Eq UA

Data UA

Ord UA

Show UA

Typeable UA

TypeOf UA

class Eq a => Expr a where

Methods

eType :: E a -> Type

constant :: a -> Const

expression :: E a -> Expression

variable :: V a -> Variable

rawBits :: E a -> E Word64

Instances

Expr Bool

Expr Double

Expr Float

Expr Int8

Expr Int16

Expr Int32

Expr Int64

Expr Word8

Expr Word16

Expr Word32

Expr Word64

data Expression

Constructors

EBool (E Bool)

EInt8 (E Int8)

EInt16 (E Int16)

EInt32 (E Int32)

EInt64 (E Int64)

EWord8 (E Word8)

EWord16 (E Word16)

EWord32 (E Word32)

EWord64 (E Word64)

EFloat (E Float)

EDouble (E Double)

data Variable

Constructors

VBool (V Bool)

VInt8 (V Int8)

VInt16 (V Int16)

VInt32 (V Int32)

VInt64 (V Int64)

VWord8 (V Word8)

VWord16 (V Word16)

VWord32 (V Word32)

VWord64 (V Word64)

VFloat (V Float)

VDouble (V Double)

Instances

Eq Variable

data Type

The type of a E.

Constructors

Bool

Int8

Int16

Int32

Int64

Word8

Word16

Word32

Word64

Float

Double

Instances

Enum Type

Eq Type

Data Type

Ord Type

Read Type

Show Type

Typeable Type

Width Type

data Const

Constructors

CBool Bool

CInt8 Int8

CInt16 Int16

CInt32 Int32

CInt64 Int64

CWord8 Word8

CWord16 Word16

CWord32 Word32

CWord64 Word64

CFloat Float

CDouble Double

Instances

Eq Const

Data Const

Ord Const

Show Const

Typeable Const

TypeOf Const

Width Const

class Width a where

Methods

width :: a -> Int

Instances

Width UE

Width UV

Width Const

Width Type

Expr a => Width (E a)

Expr a => Width (V a)

class TypeOf a where

Methods

typeOf :: a -> Type

Instances

TypeOf UE

TypeOf UA

TypeOf UV

TypeOf Const

Expr a => TypeOf (E a)

TypeOf (A a)

TypeOf (V a)

bytes :: Width a => a -> Int

ue :: Expr a => E a -> UE

Converts an typed expression (E a) to an untyped expression (UE).

uv :: V a -> UV

class (Num a, Expr a, EqE a, OrdE a) => NumE a

Instances

NumE Double

NumE Float

NumE Int8

NumE Int16

NumE Int32

NumE Int64

NumE Word8

NumE Word16

NumE Word32

NumE Word64

class (NumE a, Integral a) => IntegralE a

Instances

IntegralE Int8

IntegralE Int16

IntegralE Int32

IntegralE Int64

IntegralE Word8

IntegralE Word16

IntegralE Word32

IntegralE Word64

class (RealFloat a, NumE a, OrdE a) => FloatingE a

Instances

FloatingE Double

FloatingE Float

class (Eq a, Expr a) => EqE a

Instances

EqE Bool

EqE Double

EqE Float

EqE Int8

EqE Int16

EqE Int32

EqE Int64

EqE Word8

EqE Word16

EqE Word32

EqE Word64

class (Eq a, Ord a, EqE a) => OrdE a

Instances

OrdE Double

OrdE Float

OrdE Int8

OrdE Int16

OrdE Int32

OrdE Int64

OrdE Word8

OrdE Word16

OrdE Word32

OrdE Word64

Constants

true :: E Bool

True term.

false :: E Bool

False term.

Variable Reference and Assignment

value :: V a -> E a

Returns the value of a V.

Logical Operations

not_ :: E Bool -> E Bool

Logical negation.

(&&.) :: E Bool -> E Bool -> E Bool

Logical AND.

(||.) :: E Bool -> E Bool -> E Bool

Logical OR.

and_ :: [E Bool] -> E Bool

The conjunction of a E Bool list.

or_ :: [E Bool] -> E Bool

The disjunction of a E Bool list.

any_ :: (a -> E Bool) -> [a] -> E Bool

True iff the predicate is true for any element.

all_ :: (a -> E Bool) -> [a] -> E Bool

True iff the predicate is true for all elements.

imply :: E Bool -> E Bool -> E Bool

Bit-wise Operations

(.&.) :: Bits a => a -> a -> a

Bitwise "and"

complement :: Bits a => a -> a

Reverse all the bits in the argument

(.|.) :: Bits a => a -> a -> a

Bitwise "or"

xor :: Bits a => a -> a -> a

Bitwise "xor"

(.<<.) :: (Bits a, IntegralE a, IntegralE n) => E a -> E n -> E a

Bitwise left-shifting.

(.>>.) :: (Bits a, IntegralE a, IntegralE n) => E a -> E n -> E a

Bitwise right-shifting.

rol :: (IntegralE a, IntegralE n, Bits a) => E a -> E n -> E a

Bitwise left-rotation.

ror :: (IntegralE a, IntegralE n, Bits a) => E a -> E n -> E a

Bitwise right-rotation.

bitSize :: Bits a => a -> Int

Return the number of bits in the type of the argument. The actual value of the argument is ignored. The function bitSize is undefined for types that do not have a fixed bitsize, like Integer.

isSigned :: Bits a => a -> Bool

Return True if the argument is a signed type. The actual value of the argument is ignored

Equality and Comparison

(==.) :: EqE a => E a -> E a -> E Bool

Equal.

(/=.) :: EqE a => E a -> E a -> E Bool

Not equal.

(<.) :: OrdE a => E a -> E a -> E Bool

Less than.

(<=.) :: OrdE a => E a -> E a -> E Bool

Less than or equal.

(>.) :: OrdE a => E a -> E a -> E Bool

Greater than.

(>=.) :: OrdE a => E a -> E a -> E Bool

Greater than or equal.

min_ :: OrdE a => E a -> E a -> E a

Returns the minimum of two numbers.

minimum_ :: OrdE a => [E a] -> E a

Returns the minimum of a list of numbers.

max_ :: OrdE a => E a -> E a -> E a

Returns the maximum of two numbers.

maximum_ :: OrdE a => [E a] -> E a

Returns the maximum of a list of numbers.

limit :: OrdE a => E a -> E a -> E a -> E a

Limits between min and max.

Arithmetic Operations

div_ :: IntegralE a => E a -> E a -> E a

Division. If both the dividend and divisor are constants, a compile-time check is made for divide-by-zero. Otherwise, if the divisor ever evaluates to 0, a runtime exception will occur, even if the division occurs within the scope of a cond or mux that tests for 0 (because Atom generates deterministic-time code, every branch of a cond or mux is executed).

div0_ :: IntegralE a => E a -> E a -> a -> E a

Division, where the C code is instrumented with a runtime check to ensure the divisor does not equal 0. If it is equal to 0, the 3rd argument is a user-supplied non-zero divsor.

mod_ :: IntegralE a => E a -> E a -> E a

Modulo. If both the dividend and modulus are constants, a compile-time check is made for divide-by-zero. Otherwise, if the modulus ever evaluates to 0, a runtime exception will occur, even if the division occurs within the scope of a cond or mux that tests for 0 (because Atom generates deterministic-time code, every branch of a cond or mux is executed).

mod0_ :: IntegralE a => E a -> E a -> a -> E a

Modulus, where the C code is instrumented with a runtime check to ensure the modulus does not equal 0. If it is equal to 0, the 3rd argument is a user-supplied non-zero divsor.

Conditional Operator

mux :: Expr a => E Bool -> E a -> E a -> E a

Conditional expression. Note, both branches are evaluated!

 mux test onTrue onFalse

Array Indexing

(!) :: (Expr a, IntegralE b) => A a -> E b -> V a

Array index to variable.

(!.) :: (Expr a, IntegralE b) => A a -> E b -> E a

Array index to expression.

Smart constructors for untyped expressions.

ubool :: Bool -> UE

unot :: UE -> UE

uand :: UE -> UE -> UE

uor :: UE -> UE -> UE

ueq :: UE -> UE -> UE

umux :: UE -> UE -> UE -> UE