Chapitre 5. Fondamentaux GEL
Précédent |  | Suivant

# Chapitre 5. Fondamentaux GEL

GEL stands for Genius Extension Language. It is the language you use to write programs in Genius. A program in GEL is simply an expression that evaluates to a number, a matrix, or another object in GEL. Genius Mathematics Tool can be used as a simple calculator, or as a powerful theoretical research tool. The syntax is meant to have as shallow of a learning curve as possible, especially for use as a calculator.

## Types de données

Values in GEL can be numbers, Booleans, or strings. GEL also treats matrices as values. Values can be used in calculations, assigned to variables and returned from functions, among other uses.

### Nombres

Les entiers sont les premiers types de nombres GEL. Les entiers s'écrivent de façon habituelle.

    1234

Les nombres hexadécimaux et octaux peuvent être écrit à la manière du langage C. Par exemple :

    0x123ABC
    01234

Vous pouvez aussi saisir des nombres dans n'importe quelle base en utilisant la notation `<base>\<nombre>`. Les chiffres plus grands que 10 utilisent des lettres tout comme pour l'hexadécimal. Par exemple, un nombre en base 23 pourrait s'écrire :

    23\1234ABCD

Le deuxième type de nombres en GEL est celui des rationnels. Les rationnels sont simplement obtenus en divisant deux entiers. Il serait donc possible d'écrire :

    3/4

pour obtenir trois quarts. Les rationnels acceptent également la notation fractionnelle mixte, donc afin d'obtenir un et trois dixièmes, vous pouvez écrire :

    1 3/10

The next type of number is floating point. These are entered in a similar fashion to C notation. You can use `E`, `e` or `@` as the exponent delimiter. Note that using the exponent delimiter gives a float even if there is no decimal point in the number. Examples:

    1.315
    7.887e77
    7.887e-77
    .3
    0.3
    77e5

When Genius prints a floating point number it will always append a `.0` even if the number is whole. This is to indicate that floating point numbers are taken as imprecise quantities. When a number is written in the scientific notation, it is always a floating point number and thus Genius does not print the `.0`.

The final type of number in GEL is the complex numbers. You can enter a complex number as a sum of real and imaginary parts. To add an imaginary part, append an `i`. Here are examples of entering complex numbers:

    1+2i
    8.01i
    77*e^(1.3i)

### Important

Lorsque vous saisissez des nombres imaginaires, il doit y avoir un nombre devant le `i`. Si vous utilisez `i` tout seul, Genius l'interprète comme une référence à la variable `i`. Si vous avez besoin de faire référence à `i` tout seul, utilisez `1i` à la place.

Afin de pouvoir utiliser la notation en fraction mixte avec des nombres imaginaires, vous devez mettre la fraction mixte entre parenthèses (par exemple, `(1 2/5)i`).

### Booléens

Genius prend également en charge nativement les données booléennes. Les deux constantes booléennes sont `true` (vrai) et `false` (faux) ; ces identifiants peuvent être utilisés comme n'importe quelle autre variable. Vous pouvez aussi utiliser les identifiants `True`, `TRUE`, `False` et `FALSE` comme alias de ces précédents.

Là où une expression booléenne est attendue, vous pouvez utiliser une grandeur booléenne ou toute expression qui produit soit un nombre soit un booléen. Si Genius a besoin d'évaluer un nombre en tant que booléen, il interprète 0 comme `false` et tout autre nombre comme `true`.

Vous pouvez également faire des calculs avec des données booléennes. Par exemple :

    ( (1 + true) - false ) * true

est identique à :

    ( (true or true) or not false ) and true

Seules l'addition, la soustraction et la multiplication sont prises en charge. Si vous mélangez des nombres avec des booléens dans une expression alors les nombres sont convertis en booléens comme indiqué ci-dessus. Cela signifie que, par exemple :

    1 == true

vaut toujours `true` puisque 1 est converti en `true` avant d'être comparé à `true`.

### Chaînes de caractères

Like numbers and Booleans, strings in GEL can be stored as values inside variables and passed to functions. You can also concatenate a string with another value using the plus operator. For example:

    a=2+3;"Le résultat est : "+a

will create the string:

    Le résultat est : 5

You can also use C-like escape sequences such as `\n`,`\t`,`\b`,`\a` and `\r`. To get a `\` or `"` into the string you can quote it with a `\`. For example:

    "Barre oblique : \\ Guillemets : \" Tabulations : \t1\t2\t3"

will make a string:

    Barre oblique : \ Guillemets : " Tabulations : 	1	2	3

Do note however that when a string is returned from a function, escapes are quoted, so that the output can be used as input. If you wish to print the string as it is (without escapes), use the `print` or `printn` functions.

In addition, you can use the library function `string` to convert anything to a string. For example:

    string(22)

will return

    "22"

Strings can also be compared with `==` (equal), `!=` (not equal) and `<=>` (comparison) operators

### Null

There is a special value called `null`. No operations can be performed on it, and nothing is printed when it is returned. Therefore, `null` is useful when you do not want output from an expression. The value `null` can be obtained as an expression when you type `.`, the constant `null` or nothing. By nothing we mean that if you end an expression with a separator `;`, it is equivalent to ending it with a separator followed by a `null`.

Exemple :

    x=5;.
    x=5;

Certaines fonctions renvoient `null` quand aucune valeur ne peut être renvoyée ou quand une erreur survient. La grandeur `null` est aussi utilisée comme vecteur ou matrice vide ou comme une référence vide.

Précédent |  | Suivant
Tracé de surfaces | Sommaire | Utilisation des variables