atom-1.0.13: An EDSL for embedded hard realtime applications.

Copyright	(c) 2013 Tom Hawkins & Lee Pike
Safe Haskell	None
Language	Haskell98

Language.Atom.Expressions

Contents

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

Description

Definitions for Atom expressions, variables, and types

Synopsis

data E a where
- 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
data V a = V UV
data UE
- = 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
data UV
- = UV Int String Const
- | UVArray UA UE
- | UVExtern String Type
data A a = A UA
data UA
- = UA Int String [Const]
- | UAExtern String Type
class Eq a => Expr a where
- eType :: E a -> Type
- constant :: a -> Const
- expression :: E a -> Expression
- variable :: V a -> Variable
- rawBits :: E a -> E Word64
data Expression
- = 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
- = 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)
data Type
- = Bool
- | Int8
- | Int16
- | Int32
- | Int64
- | Word8
- | Word16
- | Word32
- | Word64
- | Float
- | Double
data Const
- = CBool Bool
- | CInt8 Int8
- | CInt16 Int16
- | CInt32 Int32
- | CInt64 Int64
- | CWord8 Word8
- | CWord16 Word16
- | CWord32 Word32
- | CWord64 Word64
- | CFloat Float
- | CDouble Double
class Width a where
- width :: a -> Int
class TypeOf a where
- typeOf :: a -> Type
bytes :: Width a => a -> Int
ue :: Expr a => E a -> UE
uv :: V a -> UV
class (Num a, Expr a, EqE a, OrdE a) => NumE a
class (NumE a, Integral a) => IntegralE a
class (RealFloat a, NumE a, OrdE a) => FloatingE a
class (Eq a, Expr a) => EqE a
class (Eq a, Ord a, EqE a) => OrdE a
true :: E Bool
false :: E Bool
value :: V a -> E a
not_ :: E Bool -> E Bool
(&&.) :: E Bool -> E Bool -> E Bool
(||.) :: E Bool -> E Bool -> E Bool
and_ :: [E Bool] -> E Bool
or_ :: [E Bool] -> E Bool
any_ :: (a -> E Bool) -> [a] -> E Bool
all_ :: (a -> E Bool) -> [a] -> E Bool
imply :: E Bool -> E Bool -> E Bool
(.&.) :: Bits a => a -> a -> a
complement :: Bits a => a -> a
(.|.) :: Bits a => a -> a -> a
xor :: Bits a => a -> a -> a
(.<<.) :: (Bits a, IntegralE a, IntegralE n) => E a -> E n -> E a
(.>>.) :: (Bits a, IntegralE a, IntegralE n) => E a -> E n -> E a
rol :: (IntegralE a, IntegralE n, Bits a) => E a -> E n -> E a
ror :: (IntegralE a, IntegralE n, Bits a) => E a -> E n -> E a
bitSize :: Bits a => a -> Int
isSigned :: Bits a => a -> Bool
(==.) :: EqE a => E a -> E a -> E Bool
(/=.) :: EqE a => E a -> E a -> E Bool
(<.) :: OrdE a => E a -> E a -> E Bool
(<=.) :: OrdE a => E a -> E a -> E Bool
(>.) :: OrdE a => E a -> E a -> E Bool
(>=.) :: OrdE a => E a -> E a -> E Bool
min_ :: OrdE a => E a -> E a -> E a
minimum_ :: OrdE a => [E a] -> E a
max_ :: OrdE a => E a -> E a -> E a
maximum_ :: OrdE a => [E a] -> E a
limit :: OrdE a => E a -> E a -> E a -> E a
div_ :: IntegralE a => E a -> E a -> E a
div0_ :: IntegralE a => E a -> E a -> a -> E a
mod_ :: IntegralE a => E a -> E a -> E a
mod0_ :: IntegralE a => E a -> E a -> a -> E a
mux :: Expr a => E Bool -> E a -> E a -> E a
(!) :: (Expr a, IntegralE b) => A a -> E b -> V a
(!.) :: (Expr a, IntegralE b) => A a -> E b -> E a
ubool :: Bool -> UE
unot :: UE -> UE
uand :: UE -> UE -> UE
uor :: UE -> UE -> UE
ueq :: UE -> UE -> UE
umux :: UE -> UE -> UE -> UE

Types

data E a where Source

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 Source

Variables updated by state transition rules.

Constructors

V UV

Instances

Eq (V a)

TypeOf (V a)

Expr a => Width (V a)

An untyped term.

Constructors

UBWShiftL UE UE

UBWShiftR UE UE

Instances

Untyped variables.

Constructors

UV Int String Const

UVExtern String Type

Instances

data A a Source

A typed array.

Constructors

A UA

Instances

Eq (A a)

TypeOf (A a)

An untyped array.

Constructors

UA Int String [Const]

UAExtern String Type

Instances

class Eq a => Expr a where Source

Typed expression:

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

data Expression Source

Typed expression

Constructors

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

Typed variable

Constructors

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

data Type Source

The type of a E .

Constructors

Instances

Typeable * Type

data Const Source

Typed constant

Constructors

Instances

Typeable * Const

class Width a where Source

Types with a defined width in bits

Methods

width :: a -> Int Source

The width of a type, in number of bits

Instances

Expr a => Width (E a)

Expr a => Width (V a)

class TypeOf a where Source

Types which have a defined Type

Methods

typeOf :: a -> Type Source

The corresponding Type of the given object

Instances

Expr a => TypeOf (E a)

TypeOf (A a)

TypeOf (V a)

bytes :: Width a => a -> Int Source

The number of bytes that an object occupies

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

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

uv :: V a -> UV Source

Convert a typed variable to an untyped one

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

Expression of numerical type

Instances

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

Expression of integral type

Minimal complete definition

signed

Instances

IntegralE Int16

IntegralE Int32

IntegralE Int64

IntegralE Word8

IntegralE Word16

IntegralE Word32

IntegralE Word64

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

Floating-point typed expression

Instances

FloatingE Double

FloatingE Float

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

Expressions which can be compared for equality

Instances

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

Expressions which can be ordered

Instances

Constants

true :: E Bool Source

True term.

false :: E Bool Source

False term.

Variable Reference and Assignment

value :: V a -> E a Source

Returns the value of a V .

Logical Operations

not_ :: E Bool -> E Bool Source

Logical negation.

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

Logical AND.

(||.) :: E Bool -> E Bool -> E Bool infixl 2 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.

Arguments

:: E Bool

a

-> E Bool

b

-> E Bool

Logical implication (if a then b).

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 Source

Bitwise left-shifting.

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

Bitwise right-shifting.

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

Bitwise left-rotation.

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

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 infix 4 Source

Equal.

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

Not equal.

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

Less than.

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

Less than or equal.

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

Greater than.

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

Greater than or equal.

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

Returns the minimum of two numbers.

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

Returns the minimum of a list of numbers.

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

Returns the maximum of two numbers.

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

Returns the maximum of a list of numbers.

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

Limits between min and max.

Arithmetic Operations

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

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 Source

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 Source

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 Source

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 Source

Conditional expression. Note, both branches are evaluated!

mux test onTrue onFalse

Array Indexing

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

Array index to variable.

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

Array index to expression.

Smart constructors for untyped expressions.

ubool :: Bool -> UE Source

Produced an untyped expression from a constant Bool

unot :: UE -> UE Source

Logical NOT of an untyped expression

uand :: UE -> UE -> UE Source

Logical AND of two untyped expressions

uor :: UE -> UE -> UE Source

Logical OR of two untyped expressions

ueq :: UE -> UE -> UE Source

Check equality on two untyped expressions

Arguments

:: UE

Selector

-> UE

Input 1

-> UE

Input 2

-> UE

2-to-1 multiplexer. If selector is true, this returns input 1; if selector is false, this returns input 2.