The demonstrator's script language is called 'HSL'. It is a minimalist language providing facilities for accuracy analysis. The language will evolve over time to become easier to use, as it lacks many features yet.

HSL is a statically typed language. It provides two types:

- integer

- float

The integer type is a signed integer encoded on 64 bits.

The float type is defined at run time. It can be a primitive type (float / double / long double in C), or a multi-precision floating point format.

HSL also provides arrays (including multidimensional arrays). More on that in the variable declaration section below.

- integer

- float

The integer type is a signed integer encoded on 64 bits.

The float type is defined at run time. It can be a primitive type (float / double / long double in C), or a multi-precision floating point format.

HSL also provides arrays (including multidimensional arrays). More on that in the variable declaration section below.

A variable can only have alphanumeric characters, plus the
underscore character. The only restriction is that it must not begin
with a numerical character. Variable names are case sensitive, and must be unique.

All variables are initialized to 0 by default.

Once declared, variables exist for the lifetime of the program.

**Variable declaration:**

Declaring a variable is just like in C. Just simply write the type followed by the variable name.

Examples:

Examples:

You can't initialize arrays at declaration time.

Arrays are index from 0.

To access to elements of the arrays, just use the operator [] like this:

All variables are initialized to 0 by default.

Once declared, variables exist for the lifetime of the program.

Declaring a variable is just like in C. Just simply write the type followed by the variable name.

Examples:

float a; integer b;By default, variables are initialized to 0. You can initialize a variable when declaring it:

float a := 3.5; integer b := 8;To declare an array, just indicate the dimensions next to the type name.

Examples:

float[5] array; float[10, 5] matrix; integer[3, 3, 3] three_dimensional_array;

You can't initialize arrays at declaration time.

Arrays are index from 0.

To access to elements of the arrays, just use the operator [] like this:

array[0] := 3.6; array[4] := 10.1; array[5] := 0; # ==> error: index out of bounds matrix[0, 4] := 33.5; matrix[b, 0] := 66.1; three_dimensional_array[0, 0, 1] := 5;

Here is the list of the operators, by order of increasing precedence:

Operator Name | Operator | Notes |
---|---|---|

Affectation operator | := | |

Logical OR | or | Unlike C/C++, operator || does not exist |

Logical AND | and | Unlike C/C++, operator && does not exist |

Equal and Not Equal | ==, != | |

Greater/Lesser, Greater or equal, Lesser or equal | <, >, <=, >= | |

Operator addition and subtraction | +, - | |

Operator multiply, divide and modulo | *, /, %, mod | Modulo can be written just '%' or in letters: 'mod' |

Unary operator + and - | +, - |

As there is no boolean type, any value evaluated to 0 is considered as false. Any other value than 0 is considered true.

If you assign a variable to the result of a boolean operation, it will receive the value of 0 (if false) or 1 (if true).

If you assign a variable to the result of a boolean operation, it will receive the value of 0 (if false) or 1 (if true).

The if statement syntax is:

**if** *cond_expr***:** *statement_if_true* **else**: *statement_if_false*

The whole**else** part is optional. You can have multiple statements if you place them in a block with { }.

A dandling**else** refers to the latest **if**.

Examples:

The whole

A dandling

Examples:

if a == 0: b := c; else: b := c / a; if a + 3 < 4: { b[a] := 5; }

The for statement syntax is:

**for** *variable* **from** *first* **to** *last* **step** *s***:** *statement*

The**step** part is optional.

Examples:

You can't have a step of 0, and you can't modify the iteration variable inside the loop.

The

Examples:

for b from 0 to 4 step 1: array[b] := a + b; # This is the equivalent in C: # for (b=0; b<=4; b = b + 1) # array[b] = a + b; # for b from 0 to 4: array[b] := a + b; # Same example, but with an implicit step of 1 # for b from 100 to 0: { array[b] := a + b; } # There is an implicit step of 1. In this case # there won't be a single iteration done. # The variable b will still be initialized to # 100, as it happens before the loop condition. # for b from 100 to 0 step -1: array[b] := a + b; # This is the equivalent of C: # for (b = 100; b >= 0; b -= 2) # array[b] = a + b;

You can't have a step of 0, and you can't modify the iteration variable inside the loop.

The while loop has the following syntax:

**while** *cond_expr***:** *statement*

Examples:

Examples:

while a < 3: a := a + 0.1; while a != 3: { a := a + 1; } while a * b + 15 <= 30 * a + 52 * b: { a := a + 1; b := b + 1; }

You have to export variable's values in order to
analyze them, and draw a chart. There are two kind of exports: *indexed
exports* and *standalone exports*.

Indexed exports are mostly used when you want to export a variable inside a loop. You must specify the index, which must be unique. Non-unique indexes will just overwrite the previous exported value.

Example:

Indexed exports are mostly used when you want to export a variable inside a loop. You must specify the index, which must be unique. Non-unique indexes will just overwrite the previous exported value.

Example:

float a; integer i; for i from 0 to 100: { export i, a; # This is an indexed export. a := a + 0.1; } export a; # This is a standalone export.

You can't define functions, but there are some predefined functions you can use at your convenience.

Most of them are mathematical functions functions of C, with correct rounding.

**float random()**

Returns a float number between 0 and 1. It is computed by dividing a random number by its largest possible value (which is 2^31 - 1).

**void random_seed_set(integer s)**

Set the seed of the random number generator.

**integer isInf( float x)**

Returns 1 if x is infinite (regardless of the sign). Returns 0 otherwise.

**float getInf()**

Returns positive infinity. You can negate it with the unary operator- .

**integer isNaN( float x)**

Returns 1 if x is Not a Number. Returns 0 otherwise.

**float getNaN()**

Returns Not a Number.

**float getConstPI()**

Returns the PI value.

The rest of the functions are mathematical functions:

**float acos ( float x)**

float asin ( float x)

float atan ( float x)

float atan2( float y, float x)

float sin( float x)

float cos( float x)

float tan( float x)

float sinh( float x)

float cosh( float x)

float tanh( float x)

float asinh( float x)

float acosh( float x)

float atanh( float x)

float exp ( float x)

float exp2 ( float x)

float log ( float x)

float log2 ( float x)

float log10( float x)

float pow ( float x, float y)

float sqrt( float x)

float abs ( float x)

float ceil ( float x)

float floor( float x)

Most of them are mathematical functions functions of C, with correct rounding.

Returns a float number between 0 and 1. It is computed by dividing a random number by its largest possible value (which is 2^31 - 1).

Set the seed of the random number generator.

Returns 1 if x is infinite (regardless of the sign). Returns 0 otherwise.

Returns positive infinity. You can negate it with the unary operator- .

Returns 1 if x is Not a Number. Returns 0 otherwise.

Returns Not a Number.

Returns the PI value.

The rest of the functions are mathematical functions:

float asin ( float x)

float atan ( float x)

float atan2( float y, float x)

float sin( float x)

float cos( float x)

float tan( float x)

float sinh( float x)

float cosh( float x)

float tanh( float x)

float asinh( float x)

float acosh( float x)

float atanh( float x)

float exp ( float x)

float exp2 ( float x)

float log ( float x)

float log2 ( float x)

float log10( float x)

float pow ( float x, float y)

float sqrt( float x)

float abs ( float x)

float ceil ( float x)

float floor( float x)

All text from the beginning of the '#' symbol to the end of the line is a comment.

Please, don't forget that this is just a demonstrator.
It is not designed for huge and complex calculus. In order to alleviate
the load of our servers, the number of iterations and the length of programs is
limited.