Scientific
Calculator:
INTRODUCTION:
The Mathematical Expression is a simple to use,
easy to integrate and extremely efficient run-time mathematical expression
parsing and evaluation engine. The parsing engine
supports numerous forms of functional and logic processing semantics and is
easily extensible.
CAPABILITIES:
The expression evaluator supports the following
fundamental arithmetic operations, functions and processes:
Types:Scalar, Vector, String
Basic operators:+, -, *, /, %, ^
Assignment::=, +=, -=, *=, /=, %=
Equalities & Inequalities:=, ==, <>, !=, <, <=, >, >=
Logic operators:and, mand, mor, nand, nor, not, or, shl, shr, xnor, xor, true, false,
Functions: abs,
avg, ceil, clamp, equal, erf, erfc, exp,
expm1, floor, frac, log, log10, log1p, log2,
logn, max,
min, mul, ncdf,
nequal, root,
round, roundn, sgn, sqrt,
sum, swap, trunc
Trigonometry:acos, acosh, asin, asinh, atan, atanh, atan2,
cos, cosh, cot,
csc, sec, sin, sinc, sinh,
tan, tanh,
hypot, rad2deg, deg2grad, deg2rad,
grad2deg
Control structures:if-then-else, ternary conditional, switch-case, return-statement
Loop statements:while, for, repeat-until, break, continue
String processing:in, like, ilike, concatenation
Optimisations:constant-folding, simple strength reduction and dead code elimination
Calculus:numerical integration and differentiation
EXAMPLE EXPRESSIONS:
The following is a short listing of the
types of mathematical expressions that can be parsed and evaluated.
sqrt(1
- (3 / x^2))
clamp(-1, sin(2 * pi * x) + cos(y / 2 * pi),
+1)
sin(2.34e-3 * x)
if(((x[2] + 2) == 3) and ((y + 5) <= 9),1
+ w, 2 / z)
inrange(-2,m,+2) == if(({-2 <= m} and [m
<= +2]),1,0)
({1/1}*[1/2]+(1/3))-{1/4}^[1/5]+(1/6)-({1/7}+[1/8]*(1/9))
a * exp(2.2 / 3.3 * t) + c
z := x + sin(2.567 * pi / y)
u := 2.123 * {pi * z} / (w := x + cos(y /
pi))
2x + 3y + 4z + 5w == 2 * x + 3 * y + 4 * z +
5 * w
3(x + y) / 2.9 + 1.234e+12 == 3 * (x + y) /
2.9 + 1.234e+12
(x + y)3.3 + 1 / 4.5 == [x + y] * 3.3 + 1 /
4.5
(x + y[i])z + 1.1 / 2.7 == (x + y[i]) * z +
1.1 / 2.7
(sin(x / pi) cos(2y) + 1) == (sin(x / pi) *
cos(2 * y) + 1)
75x^17 + 25.1x^5 - 35x^4 - 15.2x^3 + 40x^2 -
15.3x + 1
(avg(x,y) <= x + y ? x - y : x * y) +
2.345 * pi / x
while (x <= 100) { x -= 1; }
x <= 'abc123' and (y in 'AString') or
('1x2y3z' != z)
((x + 'abc') like '*123*') or ('a123b' ilike
y)
sgn(+1.2^3.4z / -5.6y) <= {-7.8^9 /
-10.11x }
Standard Deviation:
var
x[25] := { 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25 };
sqrt(sum([x
- avg(x)]^2) / x[]);
Mean
(Average):
var
x[25] := { 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25 };
avg(x);
BUILT-IN OPERATIONS & FUNCTIONS:
Arithmetic & Assignment Operators
+----------+---------------------------------------------------------+
| OPERATOR | DEFINITION |
+----------+---------------------------------------------------------+
| + | Addition between x and y. (eg: x + y) |
+----------+---------------------------------------------------------+
| - | Subtraction between x and y. (eg: x - y) |
+----------+---------------------------------------------------------+
| * | Multiplication between x and y. (eg: x * y) |
+----------+---------------------------------------------------------+
| / | Division between x and y. (eg: x / y) |
+----------+---------------------------------------------------------+
| % | Modulus of x with respect to y. (eg: x % y) |
+----------+---------------------------------------------------------+
| ^ | x to the power of y. (eg: x ^ y) |
+----------+---------------------------------------------------------+
| := | Assign the value of x to y. Where y is
either a variable|
| | or vector
type. (eg: y := x) |
+----------+---------------------------------------------------------+
| += | Increment x by the value of the
expression on the right |
| | hand side.
Where x is either a variable or vector type. |
| | (eg: x +=
abs(y - z))
|
+----------+---------------------------------------------------------+
| -= | Decrement x by the value of the
expression on the right |
| | hand side.
Where x is either a variable or vector type. |
| | (eg: x[i] -=
abs(y + z))
|
+----------+---------------------------------------------------------+
| *= | Assign the multiplication of x by the
value of the |
| | expression on
the righthand side to x. Where x is either|
| | a variable or
vector type.
|
| | (eg: x *=
abs(y / z))
|
+----------+---------------------------------------------------------+
| /= | Assign the division of x by the value
of the expression |
| | on the
right-hand side to x. Where x is either a
|
| | variable or
vector type. (eg: x[i + j] /= abs(y *
z)) |
+----------+---------------------------------------------------------+
| %= | Assign x modulo the value of the
expression on the right|
| | hand side to
x. Where x is either a variable or vector
|
| | type. (eg: x[2] %= y ^ 2) |
+----------+---------------------------------------------------------+
Equalities & Inequalities
+----------+---------------------------------------------------------+
| OPERATOR | DEFINITION |
+----------+---------------------------------------------------------+
| == or = | True only if
x is strictly equal to y. (eg: x == y)
|
+----------+---------------------------------------------------------+
| <> or != | True only if x does not equal y. (eg: x
<> y or x != y) |
+----------+---------------------------------------------------------+
| < | True only if x is less than y. (eg: x
< y) |
+----------+---------------------------------------------------------+
| <= | True only if x is less than or equal to
y. (eg: x <= y) |
+----------+---------------------------------------------------------+
| > | True only if x is greater than y. (eg:
x > y) |
+----------+---------------------------------------------------------+
| >= | True only if x greater than or equal to
y. (eg: x >= y) |
+----------+---------------------------------------------------------+
Boolean Operations
+----------+---------------------------------------------------------+
| OPERATOR | DEFINITION |
+----------+---------------------------------------------------------+
| true | True state or
any value other than zero (typically 1).
|
+----------+---------------------------------------------------------+
| false | False state,
value of zero.
|
+----------+---------------------------------------------------------+
| and | Logical AND,
True only if x and y are both true.
|
| | (eg: x and
y)
|
+----------+---------------------------------------------------------+
| mand | Multi-input
logical AND, True only if all inputs are
|
| | true. Left to
right short-circuiting of expressions.
|
| | (eg: mand(x
> y, z < w, u or v, w and x)) |
+----------+---------------------------------------------------------+
| mor | Multi-input
logical OR, True if at least one of the
|
| | inputs are
true. Left to right short-circuiting of
|
| |
expressions. (eg: mor(x > y, z <
w, u or v, w and x)) |
+----------+---------------------------------------------------------+
| nand | Logical NAND,
True only if either x or y is false.
|
| | (eg: x nand
y)
|
+----------+---------------------------------------------------------+
| nor | Logical NOR, True
only if the result of x or y is false |
| | (eg: x nor
y)
|
+----------+---------------------------------------------------------+
| not | Logical NOT,
Negate the logical sense of the input.
|
| | (eg: not(x
and y) == x nand y)
|
+----------+---------------------------------------------------------+
| or | Logical OR,
True if either x or y is true. (eg: x or y) |
+----------+---------------------------------------------------------+
| xor | Logical XOR,
True only if the logical states of x and y |
| | differ. (eg: x xor y) |
+----------+---------------------------------------------------------+
| xnor | Logical XNOR,
True iff the biconditional of x and y is
|
| |
satisfied. (eg: x xnor y) |
+----------+---------------------------------------------------------+
| & | Similar
to AND but with left to right expression short
|
| | circuiting
optimisation. (eg: (x & y) == (y and
x)) |
+----------+---------------------------------------------------------+
| | | Similar to OR
but with left to right expression short
|
| | circuiting
optimisation. (eg: (x | y) == (y or
x)) |
+----------+---------------------------------------------------------+
General Purpose Functions
+----------+---------------------------------------------------------+
| FUNCTION | DEFINITION |
+----------+---------------------------------------------------------+
| abs | Absolute
value of x. (eg: abs(x)) |
+----------+---------------------------------------------------------+
| avg | Average of
all the inputs.
|
| | (eg:
avg(x,y,z,w,u,v) == (x + y + z + w + u + v) / 6) |
+----------+---------------------------------------------------------+
| ceil | Smallest
integer that is greater than or equal to x.
|
+----------+---------------------------------------------------------+
| clamp | Clamp x in
range between r0 and r1, where r0 < r1.
|
| | (eg:
clamp(r0,x,r1)) |
+----------+---------------------------------------------------------+
| equal | Equality test
between x and y using normalized epsilon
|
+----------+---------------------------------------------------------+
| erf | Error
function of x. (eg: erf(x)) |
+----------+---------------------------------------------------------+
| erfc | Complimentary
error function of x. (eg: erfc(x)) |
+----------+---------------------------------------------------------+
| exp | e to the
power of x. (eg: exp(x)) |
+----------+---------------------------------------------------------+
| expm1 | e to the
power of x minus 1, where x is very small.
|
| | (eg:
expm1(x)) |
+----------+---------------------------------------------------------+
| floor | Largest
integer that is less than or equal to x.
|
| | (eg:
floor(x)) |
+----------+---------------------------------------------------------+
| frac | Fractional
portion of x. (eg: frac(x)) |
+----------+---------------------------------------------------------+
| hypot | Hypotenuse of
x and y (eg: hypot(x,y) = sqrt(x*x + y*y))|
+----------+---------------------------------------------------------+
| iclamp | Inverse-clamp
x outside of the range r0 and r1. Where
|
| | r0 < r1.
If x is within the range it will snap to the
|
| | closest
bound. (eg: iclamp(r0,x,r1)
|
+----------+---------------------------------------------------------+
| inrange | In-range
returns 'true' when x is within the range r0
|
| | and r1. Where
r0 < r1. (eg: inrange(r0,x,r1) |
+----------+---------------------------------------------------------+
| log | Natural
logarithm of x. (eg: log(x)) |
+----------+---------------------------------------------------------+
| log10 | Base 10
logarithm of x. (eg: log10(x)) |
+----------+---------------------------------------------------------+
| log1p | Natural
logarithm of 1 + x, where x is very small.
|
| | (eg:
log1p(x)) |
+----------+---------------------------------------------------------+
| log2 | Base 2
logarithm of x. (eg: log2(x)) |
+----------+---------------------------------------------------------+
| logn | Base N
logarithm of x. where n is a positive integer.
|
| | (eg:
logn(x,8)) |
+----------+---------------------------------------------------------+
| max | Largest value
of all the inputs. (eg: max(x,y,z,w,u,v)) |
+----------+---------------------------------------------------------+
| min | Smallest
value of all the inputs. (eg: min(x,y,z,w,u))
|
+----------+---------------------------------------------------------+
| mul | Product of
all the inputs.
|
| | (eg:
mul(x,y,z,w,u,v,t) == (x * y * z * w * u * v * t)) |
+----------+---------------------------------------------------------+
| ncdf | Normal
cumulative distribution function. (eg:
ncdf(x)) |
+----------+---------------------------------------------------------+
| nequal | Not-equal
test between x and y using normalized epsilon |
+----------+---------------------------------------------------------+
| pow | x to the
power of y. (eg: pow(x,y) == x ^ y) |
+----------+---------------------------------------------------------+
| root | Nth-Root of
x. where n is a positive integer.
|
| | (eg:
root(x,3) == x^(1/3)) |
+----------+---------------------------------------------------------+
| round | Round x to
the nearest integer. (eg: round(x)) |
+----------+---------------------------------------------------------+
| roundn | Round x to n
decimal places (eg: roundn(x,3)) |
| | where n >
0 and is an integer.
|
| | (eg:
roundn(1.2345678,4) == 1.2346) |
+----------+---------------------------------------------------------+
| sgn | Sign of x, -1
where x < 0, +1 where x > 0, else zero.
|
| | (eg:
sgn(x)) |
+----------+---------------------------------------------------------+
| sqrt | Square root
of x, where x >= 0. (eg:
sqrt(x)) |
+----------+---------------------------------------------------------+
| sum | Sum of all
the inputs.
|
| | (eg:
sum(x,y,z,w,u,v,t) == (x + y + z + w + u + v + t)) |
+----------+---------------------------------------------------------+
| swap | Swap the
values of the variables x and y and return the |
| <=> | current
value of y. (eg: swap(x,y) or x
<=> y) |
+----------+---------------------------------------------------------+
| trunc | Integer
portion of x. (eg: trunc(x)) |
+----------+---------------------------------------------------------+
Trigonometry Functions
+----------+---------------------------------------------------------+
| FUNCTION | DEFINITION |
+----------+---------------------------------------------------------+
| acos | Arc cosine of
x expressed in radians. Interval [-1,+1]
|
| | (eg:
acos(x)) |
+----------+---------------------------------------------------------+
| acosh | Inverse
hyperbolic cosine of x expressed in radians.
|
| | (eg:
acosh(x)) |
+----------+---------------------------------------------------------+
| asin | Arc sine of x
expressed in radians. Interval [-1,+1]
|
| | (eg:
asin(x)) |
+----------+---------------------------------------------------------+
| asinh | Inverse
hyperbolic sine of x expressed in radians.
|
| | (eg:
asinh(x)) |
+----------+---------------------------------------------------------+
| atan | Arc tangent
of x expressed in radians. Interval [-1,+1] |
| | (eg:
atan(x)) |
+----------+---------------------------------------------------------+
| atan2 | Arc tangent
of (x / y) expressed in radians. [-pi,+pi]
|
| | eg:
atan2(x,y) |
+----------+---------------------------------------------------------+
| atanh | Inverse
hyperbolic tangent of x expressed in radians.
|
| | (eg:
atanh(x)) |
+----------+---------------------------------------------------------+
| cos | Cosine of
x. (eg: cos(x)) |
+----------+---------------------------------------------------------+
| cosh | Hyperbolic
cosine of x. (eg: cosh(x)) |
+----------+---------------------------------------------------------+
| cot | Cotangent of
x. (eg: cot(x)) |
+----------+---------------------------------------------------------+
| csc | Cosecant of
x. (eg: csc(x)) |
+----------+---------------------------------------------------------+
| sec | Secant of
x. (eg: sec(x)) |
+----------+---------------------------------------------------------+
| sin | Sine of
x. (eg: sin(x)) |
+----------+---------------------------------------------------------+
| sinc | Sine cardinal
of x. (eg: sinc(x)) |
+----------+---------------------------------------------------------+
| sinh | Hyperbolic
sine of x. (eg: sinh(x)) |
+----------+---------------------------------------------------------+
| tan | Tangent of
x. (eg: tan(x)) |
+----------+---------------------------------------------------------+
| tanh | Hyperbolic
tangent of x. (eg: tanh(x)) |
+----------+---------------------------------------------------------+
| deg2rad | Convert x
from degrees to radians. (eg:
deg2rad(x)) |
+----------+---------------------------------------------------------+
| deg2grad | Convert x from degrees to gradians. (eg: deg2grad(x)) |
+----------+---------------------------------------------------------+
| rad2deg | Convert x
from radians to degrees. (eg:
rad2deg(x)) |
+----------+---------------------------------------------------------+
| grad2deg | Convert x from gradians to degrees. (eg: grad2deg(x)) |
+----------+---------------------------------------------------------+
String Processing
+----------+---------------------------------------------------------+
| FUNCTION | DEFINITION |
+----------+---------------------------------------------------------+
| = , == | All common equality/inequality operators
are applicable |
| !=, <> | to strings and are applied in a case
sensitive manner. |
| <=, >= | In the following example x, y and z are of
type string. |
| < , > | (eg: not((x <= 'AbC') and ('1x2y3z'
<> y)) or (z == x) |
+----------+---------------------------------------------------------+
| in | True only if
x is a substring of y.
|
| | (eg: x in y
or 'abc' in 'abcdefgh')
|
+----------+---------------------------------------------------------+
| like | True only if
the string x matches the pattern y.
|
| | Available
wildcard characters are '*' and '?' denoting
|
| | zero or more
and zero or one matches respectively.
|
| | (eg: x like y
or 'abcdefgh' like 'a?d*h')
|
+----------+---------------------------------------------------------+
| ilike | True only if
the string x matches the pattern y in a
|
| | case
insensitive manner. Available wildcard characters |
| | are '*' and
'?' denoting zero or more and zero or one
|
| | matches
respectively.
|
| | (eg: x ilike
y or 'a1B2c3D4e5F6g7H' ilike 'a?d*h')
|
+----------+---------------------------------------------------------+
| [r0:r1] | The closed
interval [r0,r1] of the specified string.
|
| | eg: Given a
string x with a value of 'abcdefgh' then:
|
| | 1. x[1:4] ==
'bcde'
|
| | 2. x[ :5] ==
x[:5] == 'abcdef'
|
| | 3. x[3: ] ==
x[3:] =='cdefgh'
|
| | 4. x[ : ] ==
x[:] == 'abcdefgh'
|
| | 5. x[4/2:3+2]
== x[2:5] == 'cdef'
|
| |
|
| | Note: Both r0
and r1 are assumed to be integers, where
|
| | r0 <= r1.
They may also be the result of an expression, |
| | in the event
they have fractional components truncation |
| | will be
performed. (eg: 1.67 --> 1) |
+----------+---------------------------------------------------------+
| := | Assign the value of x to y. Where y is
a mutable string |
| | or string
range and x is either a string or a string
|
| | range.
eg:
|
| | 1. y :=
x |
| | 2. y :=
'abc'
|
| | 3. y := x[:i
+ j]
|
| | 4. y :=
'0123456789'[2:7]
|
| | 5. y :=
'0123456789'[2i + 1:7]
|
| | 6. y := (x :=
'0123456789'[2:7])
|
| | 7. y[i:j] :=
x
|
| | 8. y[i:j] :=
(x + 'abcdefg'[8 / 4:5])[m:n]
|
| |
|
| | Note: For
options 7 and 8 the shorter of the two ranges |
| | will denote
the number characters that are to be copied.|
+----------+---------------------------------------------------------+
| + | Concatenation of x and y. Where x and
y are strings or |
| | string
ranges. eg
|
| | 1. x + y
|
| | 2. x +
'abc'
|
| | 3. x + y[:i +
j]
|
| | 4. x[i:j] +
y[2:3] + '0123456789'[2:7]
|
| | 5. 'abc' + x
+ y |
| | 6. 'abc' +
'1234567'
|
| | 7. (x +
'a1B2c3D4' + y)[i:2j]
|
+----------+---------------------------------------------------------+
| += | Append to x the value of y. Where x is
a mutable string |
| | and y is
either a string or a string range. eg:
|
| | 1. x +=
y
|
| | 2. x +=
'abc' |
| | 3. x += y[:i
+ j] + 'abc'
|
| | 4. x +=
'0123456789'[2:7]
|
+----------+---------------------------------------------------------+
| <=> | Swap
the values of x and y. Where x and y are mutable |
| | strings. (eg: x <=> y) |
+----------+---------------------------------------------------------+
| [] | The string
size operator returns the size of the string |
| | being
actioned. |
| | eg:
|
| | 1. 'abc'[] ==
3
|
| | 2. var
max_str_length := max(s0[],s1[],s2[],s3[])
|
| | 3. ('abc' +
'xyz')[] == 6
|
| | 4. (('abc' +
'xyz')[1:4])[] == 4
|
+----------+---------------------------------------------------------+
Control Structures
+----------+---------------------------------------------------------+
|STRUCTURE | DEFINITION |
+----------+---------------------------------------------------------+
| if | If x is true
then return y else return z.
|
| | eg:
|
| | 1. if (x, y,
z)
|
| | 2. if ((x +
1) > 2y, z + 1, w / v)
|
| | 3. if (x >
y) z;
|
| | 4. if (x
<= 2*y) { z + w }; |
+----------+---------------------------------------------------------+
| if-else | The
if-else/else-if statement. Subject to the condition |
| | branch the
statement will return either the value of the|
| | consequent or
the alternative branch.
|
| | eg:
|
| | 1. if (x >
y) z; else w;
|
| | 2. if (x >
y) z; else if (w != u) v;
|
| | 3. if (x <
y) {z; w + 1;} else u;
|
| | 4. if ((x !=
y) and (z > w)) |
| | {
|
| | y := sin(x) / u; |
| | z := w + 1; |
| | }
|
| | else if (x > (z + 1)) |
| | {
|
| | w := abs (x - y) + z; |
| | u := (x + 1) > 2y ? 2u : 3u; |
| | }
|
+----------+---------------------------------------------------------+
| switch | The first
true case condition that is encountered will
|
| | determine the
result of the switch. If none of the case |
| | conditions
hold true, the default action is assumed as
|
| | the final
return value. This is sometimes also known as |
| | a multi-way
branch mechanism.
|
| | eg:
|
| | switch
|
| | { |
| | case x > (y + z) : 2 * x / abs(y -
z); |
| | case x < 3 : sin(x + y); |
| | default : 1 + x; |
| | }
|
+----------+---------------------------------------------------------+
| while | The structure
will repeatedly evaluate the internal
|
| | statement(s)
'while' the condition is true. The final
|
| | statement in
the final iteration will be used as the
|
| | return value
of the loop.
|
| | eg:
|
| | while ((x -=
1) > 0)
|
| | {
|
| | y := x + z; |
| | w := u + y; |
| | }
|
+----------+---------------------------------------------------------+
| repeat/ | The structure
will repeatedly evaluate the internal
|
| until | statement(s)
'until' the condition is true. The final
|
| | statement in
the final iteration will be used as the
|
| | return value
of the loop.
|
| | eg: |
| | repeat
|
| | y := x + z; |
| | w := u + y; |
| | until ((x +=
1) > 100)
|
+----------+---------------------------------------------------------+
| for | The structure
will repeatedly evaluate the internal
|
| | statement(s)
while the condition is true. On each loop
|
| | iteration, an
'incrementing' expression is evaluated.
|
| | The
conditional is mandatory whereas the initialiser |
| | and
incrementing expressions are optional. |
| | eg: |
| | for (var x :=
0; (x < n) and (x != y); x += 1)
|
| | {
|
| | y := y + x / 2 - z; |
| | w := u + y; |
| | }
|
+----------+---------------------------------------------------------+
| break | Break
terminates the execution of the nearest enclosed |
| break[] | loop,
allowing for the execution to continue on external|
| | to the loop.
The default break statement will set the
|
| | return value
of the loop to NaN, where as the return
|
| | based form
will set the value to that of the break
|
| |
expression. |
| | eg:
|
| | while ((i +=
1) < 10)
|
| | {
|
| | if (i < 5) |
| | j -= i + 2; |
| | else if (i % 2 == 0) |
| | break; |
| | else
|
| | break[2i + 3]; |
| | }
|
+----------+---------------------------------------------------------+
| continue | Continue results in the remaining portion of the
nearest|
| | enclosing
loop body to be skipped.
|
| | eg:
|
| | for (var i :=
0; i < 10; i += 1)
|
| | { |
| | if (i < 5) |
| | continue; |
| | j -= i + 2; |
| | }
|
+----------+---------------------------------------------------------+
| return | Return
immediately from within the current expression.
|
| | With the
option of passing back a variable number of
|
| | values
(scalar, vector or string). eg:
|
| | 1. return
[1];
|
| | 2. return [x,
'abx'];
|
| | 3. return [x,
x + y,'abx'];
|
| | 4. return
[];
|
| | 5. if (x <
y)
|
| | return [x, x - y, 'result-set1',
123.456]; |
| | else
|
| | return [y, x + y, 'result-set2']; |
+----------+---------------------------------------------------------+
| ?: | Ternary
conditional statement, similar to that of the
|
| | above denoted
if-statement.
|
| | eg:
|
| | 1. x ? y :
z |
| | 2. x + 1 >
2y ? z + 1 : (w / v)
|
| | 3. min(x,y)
> z ? (x < y + 1) ? x : y : (w * v) |
+----------+---------------------------------------------------------+
| ~ | Evaluate each
sub-expression, then return as the result |
| | the value of
the last sub-expression. This is sometimes |
| | known as
multiple sequence point evaluation.
|
| | eg:
|
| | ~(i := x + 1,
j := y / z, k := sin(w/u)) == (sin(w/u))) |
| | ~{i := x + 1;
j := y / z; k := sin(w/u)} == (sin(w/u))) |
+----------+---------------------------------------------------------+
| [*] | Evaluate any
consequent for which its case statement is |
| | true. The
return value will be either zero or the result|
| | of the last
consequent to have been evaluated.
|
| | eg:
|
| | [*] |
| | {
|
| | case (x + 1) > (y - 2) : x := z / 2 + sin(y / pi); |
| | case (x + 2) < abs(y + 3) : w / 4 +
min(5y,9); |
| | case (x + 3) == (y * 4) : y := abs(z / 6) + 7y; |
| | }
|
+----------+---------------------------------------------------------+
| [] | The vector
size operator returns the size of the vector |
| | being
actioned. |
| | eg:
|
| | 1. v[]
|
| | 2. max_size
:= max(v0[],v1[],v2[],v3[])
|
+----------+---------------------------------------------------------+
Note: In the tables above, the symbols x,
y, z, w, u and v where appropriate may represent any of one the following:
1. Literal numeric/string value
2. A variable
3. A vector element
4. A vector
5. A string
6.
An expression comprised of [1], [2] or [3] (eg: 2 + x / vec[3])
FUNDAMENTAL TYPES:
Supports three fundamental types which can be
used freely in expressions. The types are as follows:
Scalar
Vector
String
Scalar Type:
The scalar type is a singular numeric value. The
underlying type is that used to
specialize the components
(float,
double, long double, MPFR et al).
Vector Type:
The vector type is a fixed size sequence of
contiguous scalar values. A vector can be indexed resulting in a scalar value.
Operations between a vector and scalar will
result in a vector with a size equal to
that of the original vector, whereas
operations between vectors will result in a
vector of size equal to that of the smaller of the two. In both mentioned
cases, the operations will occur element-wise.
String Type:
The string type is a variable length sequence of
8-bit chars. Strings can be assigned and
concatenated to one another,
they can also be manipulated via sub-ranges using
the range definition syntax. Strings however can not interact with
scalar or vector types.