 | atom-1.0.7: A DSL for embedded hard realtime applications. | Contents | Index |
|
Language.Atom.Expressions |
|
|
|
|
|
Synopsis |
|
| | data V a = V UV | | | | | | data A a = A UA | | | | class Eq a => Expr a where | | | | | | | | | | | class Width a where | | | class TypeOf a where | | | bytes :: Width a => a -> Int | | ue :: Expr a => E a -> UE | | uv :: V a -> UV | | ueUpstream :: UE -> [UE] | | nearestUVs :: UE -> [UV] | | arrayIndices :: UE -> [(UA, UE)] | | 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 | | (==.) :: 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 |
A typed expression.
| Constructors | | 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 | | Instances | |
|
|
data UE |
An untyped term.
| Constructors | | Instances | |
|
|
data UV |
Untyped variables.
| Constructors | | Instances | |
|
|
data A a |
A typed array.
| Constructors | | Instances | |
|
|
data UA |
An untyped array.
| Constructors | | Instances | |
|
|
class Eq a => Expr a where |
| Methods | | | Instances | |
|
|
data Expression |
|
|
data Variable |
Constructors | | Instances | |
|
|
data Type |
The type of a E.
| Constructors | Bool | | Int8 | | Int16 | | Int32 | | Int64 | | Word8 | | Word16 | | Word32 | | Word64 | | Float | | Double | |
| Instances | |
|
|
data Const |
Constructors | | Instances | |
|
|
class Width a where |
| Methods | | | Instances | |
|
|
class TypeOf a where |
| Methods | | | Instances | |
|
|
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 |
|
ueUpstream :: UE -> [UE] |
The list of UEs adjacent upstream of a UE.
|
|
nearestUVs :: UE -> [UV] |
The list of all UVs that directly control the value of an expression.
|
|
arrayIndices :: UE -> [(UA, UE)] |
All array indexing subexpressions.
|
|
class (Num a, Expr a, EqE a, OrdE a) => NumE a |
| Instances | |
|
|
class (NumE a, Integral a) => IntegralE a |
| Instances | |
|
|
class (RealFloat a, NumE a, OrdE a) => FloatingE a |
| Instances | |
|
|
class (Eq a, Expr a) => EqE a |
| Instances | |
|
|
class (Eq a, Ord a, EqE a) => OrdE a |
| Instances | |
|
|
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 |
|
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 |
|
Produced by Haddock version 2.7.2 |