Language.Atom.Expressions

Contents

Types
Constants
Variable Reference and Assignment
Logical Operations
Equality and Comparison
Arithmetic Operations
Conditional Operator
Array Indexing
Smart constructors for untyped expressions.

Synopsis

Types

data E a whereSource

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
Shift :: IntegralE a => E a -> Int -> 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 Source

Variables updated by state transition rules.

Constructors

V UV

Instances

Eq (V a)
TypeOf (V a)
Expr a => Width (V a)

data UE Source

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
UShift UE Int
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 Source

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 Source

A typed array.

Constructors

A UA

Instances

Eq (A a)
TypeOf (A a)

data UA Source

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 whereSource

Methods

eType :: E a -> Type Source

constant :: a -> Const Source

expression :: E a -> Expression Source

variable :: V a -> Variable Source

rawBits :: E a -> E Word64 Source

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 Source

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 Source

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 Source

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 Source

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 whereSource

Methods

width :: a -> Int Source

Instances

Width UE
Width UV
Width Const
Width Type
Expr a => Width (E a)
Expr a => Width (V a)

class TypeOf a whereSource

Methods

typeOf :: a -> Type Source

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 Source

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

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

uv :: V a -> UV Source

ueUpstream :: UE -> [UE]Source

The list of UEs adjacent upstream of a UE.

nearestUVs :: UE -> [UV]Source

The list of all UVs that directly control the value of an expression.

arrayIndices :: UE -> [(UA, UE)]Source

All array indexing subexpressions.

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

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 Source

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 Source

Instances

FloatingE Double
FloatingE Float

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

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 Source

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 Source

True term.

false :: E Bool Source

False term.

Variable Reference and Assignment

value :: V a -> E aSource

Returns the value of a V.

Logical Operations

not_ :: E Bool -> E Bool Source

Logical negation.

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

Logical AND.

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

Logical OR.

and_ :: [E Bool] -> E Bool Source

The conjunction of a E Bool list.

or_ :: [E Bool] -> E Bool Source

The disjunction of a E Bool list.

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

True iff the predicate is true for any element.

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

True iff the predicate is true for all elements.

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

Equality and Comparison

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

Equal.

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

Not equal.

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

Less than.

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

Less than or equal.

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

Greater than.

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

Greater than or equal.

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

Returns the minimum of two numbers.

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

Returns the minimum of a list of numbers.

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

Returns the maximum of two numbers.

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

Returns the maximum of a list of numbers.

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

Limits between min and max.

Arithmetic Operations

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

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 aSource

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 aSource

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 aSource

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 aSource

Conditional expression. Note, both branches are evaluated!

 mux test onTrue onFalse

Array Indexing

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

Array index to variable.

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

Array index to expression.

Smart constructors for untyped expressions.

ubool :: Bool -> UE Source

unot :: UE -> UE Source

uand :: UE -> UE -> UE Source

uor :: UE -> UE -> UE Source

ueq :: UE -> UE -> UE Source

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