Documentation du démonstrateur

Le langage script du démonstrateur s'appelle 'HSL'. Il s'agit d'un langage minimaliste qui permet d'effectuer des analyses de précision. Le langage évoluera au fil du temps pour devenir plus facile à utiliser, car il manque encore de nombreuses fonctionnalités.

Types

HSL est un langage de type statique. Il en existe deux types :
- entiers
- flottants

Le type entier est un entier signé codé sur 64 bits.
Le type de flottant est défini au moment de l'exécution. Il peut s'agir d'un type primitif (float / double / long double en C), ou d'un format point flottant multiprécision.
HSL fournit également des tableaux (y compris des tableaux multidimensionnels). Pour plus d'informations à ce sujet, reportez-vous à la section Déclaration des variables ci-dessous.

Variables

Une variable ne peut avoir que des caractères alphanumériques, plus le caractère de soulignement. La seule restriction est qu'il ne doit pas commencer par un caractère numérique. Les noms de variables sont sensibles aux caractères et doivent être uniques.
Toutes les variables sont initialisées à 0 par défaut.
Une fois déclarées, les variables existent pendant toute la durée de vie du programme

Déclaration de variable :
Déclarer une variable est comme dans C. Il suffit simplement d'écrire le type suivi du nom de la variable.
Exemples :
float a;
integer b;

Par défaut, les variables sont initialisées à 0, il est possible d’initialiser une variable lors de sa déclaration :
">float a := 3.5;
integer b := 8;

Pour déclarer un tableau, il suffit d'indiquer les dimensions à côté du nom du type.
Exemples:

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


Vous ne pouvez pas initialiser les tableaux au moment de la déclaration.
Les tableaux sont indexés à partir de 0.
Pour accéder aux éléments des tableaux, il suffit d'utiliser l'opérateur [] comme ceci :

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;

Opérateurs

Voici la liste des opérateurs, classés par ordre de priorité croissant : 

Nom de l'opérateur OpérateurNotes
Opérateur d'affectation:=
Logical ORorContrairement à C/C++, l’opérateur || n’existe pas
Logical ANDandContrairement à C/C++, l’opérateur & n’existe pas
Equal and Not Equal==, !=
Greater/Lesser, Greater or equal, Lesser or equal<, >, <=, >=
Operator addition and subtraction+, -
Operator multiply, divide and modulo
*, /, %, modModulo peut être écrit '%' ou en lettres : 'mod'
Unary operator + and -+, -

Structures de contrôle

Comme il n'y a pas de type booléen, toute valeur évaluée à 0 est considérée comme fausse. Toute autre valeur que 0 est considérée comme vraie.
Si vous affectez une variable au résultat d'une opération booléenne, elle recevra la valeur 0 (si c’est faux) ou 1 (si c’est vrai).

Déclaration : if

La syntaxe de déclaration if est :
if cond_expr: statement_if_true else: statement_if_false
La partie entière else est facultative. Il est possible d’avoir plusieurs instructions lorsqu’elles sont placées dans un bloc avec { }.
Un else orphelin se réfère au dernier if.

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

Déclaration : for

La syntaxe de déclaration for est :
for variable from first to last step s: statement
La partie step est optionnelle.

Exemples :
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;

Il n’est pas possible d’avoir une marche de 0 et il n’est pas possible de modifier la variable itérative dans la boucle.

Déclaration : while

La boucle while à la syntaxe suivante :
while cond_expr: statement

Exemples :
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;
}

Déclaration d'exportation

Il faut exporter les valeurs des variables afin de les analyser et tracer un graphique. Il existe deux types d'exportations : les exportations indexées et les exportations autonomes.
Les exportations indexées sont surtout utilisées lorsque l’on veut exporter une variable à l'intérieur d'une boucle. Il faut spécifier l'index, qui doit être unique. Les indices non uniques remplaceront simplement la valeur exportée précédente.

Exemple :
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.

Fonctions

Il n’est pas possible de définir des fonctions mais il existe des fonctions prédéfinies que l’on peut utiliser à sa convenance. 

float random()
Renvoie un nombre flottant entre 0 et 1. Il est calculé en divisant un nombre aléatoire par sa plus grande valeur possible (qui est 2^31 - 1).

void  random_seed_set(integer s)
Définit la graine du générateur de nombres aléatoires .

integer isInf( float x)
Renvoie 1 si x est infini (quel que soit le signe). Sinon renvoie 0.

float   getInf()
Renvoie l’infini positif. Possibilité de l’annuler avec l’opérateur unaire.

integer isNaN( float x)
Renvoie 1 si x n’est pas un nombre. Sinon renvoie 0. 

float   getNaN()
Ne renvoie pas de nombre.

float   getConstPI()
Renvoie la constante PI.

Le reste des fonctions sont des fonctions mathématiques :
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)

Commentaire

Tout le texte depuis le début du symbole '#' jusqu'à la fin de la ligne est un commentaire.

Limites

S'il vous plaît, n'oubliez pas que ce n'est qu'un démonstrateur. Il n'est pas conçu pour les calculs énormes et complexes. Afin d'alléger la charge de nos serveurs, le nombre d'itérations et la durée des programmes est limité.