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 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 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 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)) /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 };
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/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, '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[])