Tutorial
Configuration
Environment managment
Graph managment
Rules managment
Execution managment

C++ Mathematical Expression Library
The rules expression is analysed thanks to the Arash Partow C++ Mathematical Expression Library.
In this section will be explained only the topics we need in the project.
Assignment and Arithmetics
A declaration of a single variable is done by var x; where x is the variable name.
A declaration of an array of size n is done by var x[n]; where x is the array name. x[i] gives the value at the index i of the array. x[] gives the length of the array.
The operator of assignement is :=
The return value of a procedure is return [ ]; where the variable name is put in [] of return.
The arithmetic operations are as follow:
+ 
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) 
+= 
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 righthand side to x. Where x is either a variable or vector type.
(eg: x /= 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)

Boolean operators , equalities and inequalities
The equality or inequality operators are:
== 
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) 
The boolean operators are:
true 
True state or any value other than zero (typically 1). 
false 
False state, value of exactly zero. 
and 
Logical AND, True only if x and y are both true. (eg: x and y) 
mand 
Multiinput logical AND, True only if all inputs are true.
Left to right shortcircuiting of expressions. (eg: mand(x > y, z < w, u or v, w and x)) 
mor 
y, z < w, u or v, w and x)) 
nor 
Logical NOR, True only if the result of x or y is false (eg: x nor y) 
not 
ogical 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 if 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)) 
Mathematical Functions
The mathematical functions implemented are:
abs 
absolute value of x (eg:abs(x)) 
ceil 
Smallest integer that is greater than or equal to x. 
exp 
e to the power of x (eg exp(x)) 
floor 
argest integer that is less than or equal to x. (eg: floor(x)) 
log 
natural logarithm of x 
log10 
Base 10 logarithm of x. (eg: log10(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)) 
root 
NthRoot 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)) /td>

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)) 
swap or <=> 
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)) 
rand 
random value (eg rand(x)) 
All the trigonometric functions are defined:sin(x),cos(x),tan(x),cot(x),acos(x),asin(x),atan(x),
atan2(x,y).
All the hyperbolic function are defined : sinh(x),cosh(x),tanh(x),atanh(x),acosh(x),asinh(x).
Some vector transformation are defined:
rotation 
make the rotation of a vector to another. rotation(V,A,C,theta,Z) Z is the rotation of V with respect to the axe A with center C and angle theta.
if Z is omitted V is changed to its rotation vector. A is [0,0,1], C is [0,0,0] and theta is 0 by default.

vectorialProduct 
vector product between 2 vectors : vectorialProduct(V,W,Z) is Z=V^W, vectorialProduct(V,W) is V=V^W

String Functions
The string manipulation functions implemented are:
= , ==
!=, <>
<=, >=
< , > 
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]

<=>

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
To manipulate loops, the following functions are needed:
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 };

ifelse

The ifelse/elseif 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 multiway 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/until

The structure will repeatedly evaluate the internal
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[]

Break terminates the execution of the nearest enclosed
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, 'resultset1', 123.456];
else
return [y, x + y, 'resultset2'];

?:

Ternary conditional statement, similar to that of the
above denoted ifstatement.
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 subexpression, then return as the result
the value of the last subexpression. 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[])

