LE LANGAGE

       généralités
       sérateurs
       opérateurs
       conditions
       boucles
       fonctions
       directive
       variables
       fonctions mathématiques
       entrées-sorties

















































GÉNÉRALITÉS

        La syntaxe du langage ANYFLO reprend celle, bien connue, du langage C, avec des simplifications et des extensions:


simplifications
extensions
commentaires

Les simplifications

1) Pas de déclarations: Les types et les dimensions des objets sont définis dynamiquement, ainsi on peut écrire successivement:
       x = 1; x est un nombre.
       x = 1,2,3; x est un tableau de nombres.
       x = "toto"; x est une chaîne de caractères.
       x = "toto",[1,6]; x est de type hybride.
Pour connaître le type d´une variable v faire status var("v").

2) Les parenthèses peuvent être omises lorsqu´il n´y a pas d´ambiguité.
Exemples:
       $(1+2*3); ou $ 1+2*3; produisent le même résultat 7
       $(cos(PI/4)); ou $ cos PI/4; produisent le même résultat 0.707107

3) Pas de structure. En fait toute variable est un tableau hybride, exemple: x=1,"AB",[2,5]; définit x comme structure dont le 1er champ est le nombre 1, le 2ème champ est la chaîne de caractères "AB" et dont le 3ème champ est le tableau (2,3,4,5).

Les extensions

1) Calculs sur les tableaux, ainsi:
       x = [1,5];y = [11,15];
       $(x + 2 * y); imprime (23.0,26.0,29.0,32.0,35.0)

2) Une fonction peut retourner un objet quelconque, ainsi:
       f(n)
       {
       return[1,n];
       }

       $f(5); imprime (1.0,2.0,3.0,4.0,5.0)

3) Le switch est généralisé à des expressions quelconques.

Les commentaires

Tout le texte compris entre /* et */ est considéré comme commentaire et ignoré par le compilateur.
De même pour le texte compris entre // et une fin de ligne.

LES SÉPARATEURS

Les mots sont séparés par:
       Des espaces
       Des tabulations
       Des retours à la ligne
       Des opérateurs
       Des parenthèses ( )
       Des crochets [ ]
       Des accolades { }

LES OPÉRATEURS

arithmetiques
logiques
connecteurs logiques

Les opérateurs arithmétiques

1) + est l´opérateur addition.
Exemples:
       1 + 3; retourne 4
       (1,2,3) + (4,5,6); retourne 5.0 7.0 9.0
Remarque: x = x + 1; peut s´écrire x++; (l´incrément est fait après usage de x) ou ++x; (l´incrément est fait avant usage de x)
Exemples:
       x=1;$x++;$x; imprime 1.0 2.0
       x=1;$++x;$x; imprime 2.0 2.0

2) - est l´opérateur de la soustraction.
Exemples:
       1 - 3; retourne -2
       (1,2,3) - (4,5,6); retourne -3.0 -3.0 -3.0
Remarques:
       x = x - 1; peut s´écrire x--; (le décrement est fait après usage de x) ou --x; (le décrement est fait avant usage de x)
Exemples:
       x=1;$x--;$x; imprime 1.0 0.0
       x=1;$--x;$x; imprime 0.0 0.0
       Comme opérateur unaire le signe - change le signe d´une expression
Exemples:
       $(-1); imprime -1
       $(-(1 - 3)); imprime 2

3) * est l´opérateur de la multiplication.
Exemples:
       2 * 3; retourne 6
       (1,2,3) * (4,5,6); retourne 4.0 10.0 18.0

4) / est l´opérateur de la division.
Exemples:
       1 / 2; retourne 0.5
       (1,2,3) / 2; retourne 0.5 1.0 1.5

       Une division par zéro provoque un message de WARNING (mais ne plante pas le programme).

5) ^ est l´opérateur d´élévation à une puissance.
Exemples:
       2 ^ .5; retourne la racine carrée de 2: 1.414214
       2 ^ -1; retourne l´inverse de 2: 0.5


Affectation">
6) = est l´operateur d´affectation.
Exemples:
       x = 1; Donne à la variable x la valeur 1
Remarques:
1) Affectations multiples:
       z=y=x=2; est équivalent à x=2;y=2;z=2;
2) x = op expr est équivalent à x = x op expr
Exemples:
       x += 2; est équivalent à x = x + 2;
       x -= 1; est équivalent à x = x - 1;
       x *= 5; est équivalent à x = x * 5;
       x /= 2; est équivqlent à x = x / 2;
       x ,=(1,2,3,4); est équivalent à x = x,(1,2,3,4);

Les opérateurs logiques

1) == est l´opérateur d´égalité.
Exemples:
       7 == 7; product 1 (vrai)
       1 == 0; product 0 (faux)

2) < est l´opérateur ´inférieur´.
Exemples:
       1 < 2; retourne 1 (vrai)
       1 > 2; retourne 0 (faux)

3) <= est l´opérateur ´inférieur ou egal´.
Exemples:
       7 <= 7; retourne 1 (vrai)
       7 <= 6; retourne 0 (faux)

4) > est l´opérateur ´supérieur´.
Exemples:
       1 > 0; retourne 1 (vrai)
       1 > 2; retourne 0 (faux)

5) >= est l´opérateur ´plus grand ou egal´.
Exemples:
       5 >= 5; retourne 1 (vrai)
       5 >= 4; retourne 0 (faux)

6) != est l´opérateur ´different´.
Exemples:
       1 != 2; retourne 1 (vrai)
       1 != 1; retourne 0 (faux)

7) ~ est l´opérateur ´peu different´.
Exemples:
       1 ~ 1.05; retourne 1 (vrai)
       1 ~ 1.5; retourne 0 (faux)
Remarque:
       La précision est par défaut de 0.1 et peut être modifiée par la commande: precision(valeur).
Exemples:
       precision(10)(1 ~ 10; product 1 (vrai)
       precision(1);1 ~ 2.1; product 0 (faux)

8) || est l´opérateur du ´ou logique´.
Exemples:
       0 || 0; product 0 (faux)
       0 || 1; product 1 (vrai)
       1 || 0; product 1 (vrai)
       1 || 1; product 1 (vrai)

9) && est l´opérateur du ´et logique´.
Exemples:
       0 && 0; product 0 (faux)
       0 && 1; product 0 (faux)
       1 && 0; product 0 (faux)
       1 && 1; product 1 (vrai)

10) ! est l´opérateur de la négation.
Exemples:
       !0; retourne 1 (vrai)
       !1; retourne 0 (faux)
       !(1<0); retourne 1 (vrai)
Remarques:
! retourne NIL.
!"string" retourne NIL.

Les connecteurs logiques

1) & est le connecteur ´et´.
Exemples:
       1 & (1 < 2); product 1 (vrai)
       1 & (1 > 2); product 0 (faux)

2) | est le connecteur ´ou´.
Exemples:
       $(1 | (1 > 2)); imprime 1 (vrai)
       $(0 | (1 > 2)); imprime 0 (faux)

LES EXPRESSIONS CONDITIONNELLES

if
switch

L´instruction if

1) 1ère forme:
       if (condition) { ... }
Exemples:
       if (1 > 0) $"OK"; imprime OK
       if (1 < 0) $"OK"; n´imprime rien

2) 2ème forme
       if (condition) { ...} else { ... }
Exemples:
       if (1 > 0) $"OK" else "BAD"; imprime OK
       if (1 < 0) $"OK" else "BAD"; imprime BAD

L´instruction switch

Syntaxe:
switch(expr)
       {
       case(expr1):
       ...
       break
       case(expr2):
       ...
       break
      
       ...
      
       default:
       ...
       }

Remarque:
       Alors qu´en C les cases sont nécessairement limités à des entiers, dans le langage ANYFLO ils peuvent concerner n´importe quelle expression évaluable mise entre parenthèse
Exemples:
       case 1:
       case(-1.2):
       case((1,2,3)):
       case("AB"):
       case(x+2*y):
       etc...

LES BOUCLES

for
while
goto

Les boucles for

1ère forme: for(initialisation;condition;incrément) {...}
Exemples:
       for(i=1;i<=5;i++) $i; imprime 1.0 2.0 3.0 4.0 5.0
       i=1;for(;i<=5;i+=1)$i; imprime le meme resultat
       for(i=1;i<=5;)$i++; imprime le meme resultat
       i=1;for(;;){$i;if(i++>4)break}; imprime le meme resultat

2ème forme: for(i=debut,end,pas) {...}
Exemples:
       for(i=1,5)$i; imprime 1.0 2.0 3.0 4.0 5.0
       for(i=1,5,2)$i; imprime 1.0 3.0 5.0
Remarque:
       La 2ème forme est plus vite exécutée, mais les bornes ne peuvent pas être changées dans le corps de la boucle

La boucle while

Syntaxe: while(condition) {...}
Exemples:
       i=1;while(i++<5)$i; imprime 2.0 3.0 4.0 5.0
       i=1;while(1){$i;if(i++>4)break}; imprime le meme resultat
Exercices:
       a=1;b=10;for(i=1;i<=b;i++){$i;b--}
       a=1;b=10;for(i=a,b){$i;b--}
       3) for(i=1,6){for(j=1,6)$"*";$"\n"}

4-3 l´instructions de branchement goto


Exemple:
       i=1;A:$i++;if(i<5)goto A;
       imprime 1.0 2.0 3.0 4.0

LES FONCTIONS

Écriture
définition
Appel
Paramètres formels
Remarque
Paramètres de type fonction
Fonction dynamique
Fonction particulière
Fonction locale

Écriture

       En mode interactif (après le point d´interrogation de l´interpréteur) toute expression, suivie dun retour charriot, est évaluée.
       Une fonction est une suite de lignes de code exécuté à la demande par l´évocation de son nom.
       Une fonction peut s´écrire soit:
       1) Avec l´éditeur de texte d´ANYFLO.
       2) Avec n´importe quel éditeur (ne codant pas le texte) en dehors d´ANYFLO (par exemple avec vi sous UNIX, ou l´éditeur de VisualC++ sous Windows), le nom du fichier front avoir une extension .func (par exemple: toto.func).
Remarque:
       L´extension .fon est également valable (mais déconseillée car pouvant être confondue avec les fichiers de fontes sous Windows).
       Un nombre quelconque de fonctions peuvent être écrites dans un même fichier.

Définition

Une fonction est définie par:
       1) Un nom suivi d´une liste de paramètres formels entre parenthèses.
Ce nom ne doit pas commencer par le caractère _ (reservé aux fonctions écrites en C).
       2) Une accolade ouvrante
       3) Une suite de lignes d´instructions
       4) Une accolade fermante
Exemple:
       f(x, y)
       {
       $(x,y);
       }
Le nom d´une fonction ne doit pas être celui d´une commande.

Appel

       Une fonction est appelée par son nom suivi d´une liste de paramètres actuels entre parenthèses
Exemples:
       f(1, 2); Produit 1.0 2.0
       f("AB",([1,5])); Produit AB 1.0 2.0 3.0 4.0 5.0

Paramètres formels

Un paramètre formel ne correspondant à aucun paramètre d´appel prend la valeur NIL.

Des fonctions peuvent être passées en paramètres d´une fonction.
Exemple:
       a(b, n)
       func b;
{
       $b(n);
}

       a("cos", PI/4); Produit 0.707107
       a("tan", PI/4); Produit 1
      

Un paramètre formel peut être une adresse.

Remarques:

       1) Alors qu´en C la 1ère fonction appelée est nécessairement ´main´, dans le langage ANYFLO n´importe quelle fonction peut être appelée indépendamment.
       2) L´appel nnn(...) provoque la recherche du nom nnn d´abord dans la liste des commnades d´ANYFLO, ensuite dans la liste des fonctions présentes en mémoire puis dans les fichiers fonctions du directory courant puis du directory de l´environnement et enfin du directoru de l´utilisateur (il n´est donc pas nécessaire de charger une fonction pour l´exécuter).
       3) Par défaut les fonctions sont automatiquement compilées et linkées à chaque modification de l´une d´entre elles, lors d´un chargement d´un fichier de fonctions ou lors de l´appel à une fonction sur le disque ou aussi quand l´une d´elles est modifiéee avec l´éditeur de texte d´anyflo (même en cours d´éxecution).
       4) Les commandes compile et link permettent d´effectuer ces opérations sur certaines fonctions. Les commandes no compile et yes compile permettent d´inhiber et de rétablir la compilation automatique.
       5) read func "nom": Permet de lire un fichier de fonctions (en écrasant les fonctions présentes en mémoire).
       6) add func "nom": Permet d´ajouter un fichier de fonctions aux fonctions présentes en mémoire.
       7) write func "nom": Permet de garer sur le disque les fonctions présentes en mémoire.
       8) Les fonctions sont récursives.
Exemple:
       factorielle(n)
       {
       if (n == 0) return 1;
       else return(n * factorielle(n - 1));
       }

       definit récursivement la fonction factorielle
       $factorielle(0); imprime 1
       $factorielle(3); imprime 6
      
Voir factorielle.func.
Autre exemple courbe de Von Koch.

Paramètres de type fonction

Si un paramètre formel est déclaré de type func tout de suite après le nom de la fonction et avant la 1ère { il pourra être appelé par un nom de commande ou de fonction placé entre ".

Fonctions dynamiques

       Des fonctions peuvent être générées dynamiquement en cours d´exécution. La commande generate func("ttt") définit, et compile, la fonction dont le code est la chaîne de caractères ttt. Une telle chaîne pouvant être générée par programme, la programmation d´anyflo est donc dynamic (application possible à la programmation génétique);

Fonctions particulières

       Certains algorithmes (comme la mise en perspective, les textures 3d, l´éclairement, etc...) sont implémentés dans anyflo de façon standard
       Il est cependant possible à l´utilisateur d´implementer lui-même de tels algorithmes en langage anyflo
Exemple:
       texture vol(1)="toto"; Lors de l´affichage du volume 1 la fonction toto sera exécutée à chaque affichage d´un pixel. Dans une telle fonction on pourra par exemple calculer la couleur en fonction de la position
       Il est aussi possible d´écrire de telles fonctions directement en C dans le fichier utilb.c de l´environnement, voir manuel.applic.htm.

Fonctions locales à un objet

       Il est possible de construire des acteurs, c´est à dire des objets définis par des datas et un programme. Celui-ci est un ensemble de fonctions (dites locales) propres à un tel objet et constituant un véritable programme (avec son propre code et des mémoires locales) pouvant être exécuté "en parallele" dans différents objets.
Syntaxe: local(0)obj(i)="toto"; ajoute la fonction locale toto aux fonctions locales de l´objet id.
       Les fonctions locales à un objet définissent son comportement, elles peuvent s´appeler les unes les autres, et il est également possible de les exécuter individuellement depuis l´extérieur.
       (voir local) (voir manuel.object.htm).

Directives

define
include
Compilation conditionnelle
Visibilité d´une directive

Directive define

#define chaine1 chaine2
       Remplace toutes les occurrences de chaine1 par chaine2.
Rermarques:
1) #define D: D est défini mais no initialisé.
2) On écrit #define D en mode interpréteur pour une compilation conditionnelle.
Exemple:
a()
{
#ifdef D
$"D est defini";NL;
#endif
}
a(); ne product rien.
#define D;a(); product "D est defini"
rem("define D")
       Supprime le define global D
rem("define")
       Supprime tout les define globaux
edit("define")
       Edite tout les define globaux

Directives include

#include nnn
       Charge le fichier nnn selon une syntaxe voisine de celle du langage C.
#include f()
       Charge le texte de la fonction f (celle-ci doit être définie avant dans le même fichier ou dans un autre inclu avant).
Exemple:
demo0_include.func qui inclut les fichiers:
       include0_define.h où sont définis Define_1 et Define_2.
       include0_externes.func où sont déclarés externes les variables Global_0 et Global_1.
       include0_1.func incluant lui-même
              include0_2.func
qui incluent tout deux la fonction externes() et manipulent les variables Global_0 et Global_1.

Compilation conditionnelle

#ifdef D
       Si D a été défini par:
#define D 1
le code situé entre #ifdef D et #endif est ignoré.
#endif
       Fin d´un bloc de compilation conditionnelle.
Remarque:
       Une compilation conditionnelle n´est prise en compte qu´après une compilation et un link, c´est à adire après un:
read func ou après un
compile.

Visibilité d´une directive

       Si elle est placée en tête de fichier elle s´applique à toutes les fonctions écrites dans ce fichier.
       Si elle est placée en tête de fonction elle ne s´applique qu´à l´intérieur de cette fonction.

VARIABLES


type
formelles
automatiques
globales
externes
statiques
visibilité
pointeur
adresse
noms
func

Type

       Les variables sont de type dynamic connues à leurs définitions qui n´ont donc pas à être déclarées.
Ainsi:
x="ab cd\tefg\nhijk"; définie x comme variable de type char (chaîne de caractères).
x=1.23; définie x comme variable de type float (nombre réel) .
x=1,2,3,4,5; définie x comme variable de type tableau de float.
x="ab cd",[1,5],"AB"; définie x comme variable de type hybride (concaténation de caractères et de floats).

Dimension d´une variable

Elle dépend de son type:
char: nombre de caractères, par exemple:
       dim("a bc def") retourne 8.
       NP("a bc def") retourne 3 (nombre de mots qui sont séparés par un espace une tabulation une virgule ou un \n).

float: nombre de flotants, par exemple:
       dim(1,2,3,4,5,6) retourne 6.
       NP(1,2,3,4,5,6) retourne 2 (nombre de composantes 3D).
édition d´un vecteur de float peut se faire selon un format donné:
       edit w imprime le format 3D par défaut:
              1 2 3
              4 5 6
edit(w)format(2) imprime le format 2D:
              1 2
              3 4
              5 6

hybride: nombre de flotants, par exemple:
       dim(1,"a bc def",2,3,4,5), ou NP(1,"a bc def",2,3,4,5) retournent 3: nombre de vecteurs de dimensions variables qui peuvent être obtenus par:
       w{0} retourne 1.
       w{1} retourne "a bc def".
       w{3} retourne 2,3,4,5.

Variables formelles

       Dont les noms apparaissent dans la déclaration de la fonction.

Variables automatiques

       Utilisées sans déclaration dans une fonction, elles sont inconnues à l´extérieur et perdent leur valeur en sortie de la fonction.

Variables globales

       Dans un objet ayant des fonctions locales les variables locales ne sont connues que dans l´ensemble de ces fonctions.
Déclaration: local x;

Variables externes

       Par défaut toutes les variables initialisées hors des fonctions (c´est à dire directement après le point d´interrogation de l´interpréteur) sont connues partout où elles sont déeacute;clarées extern.
       Dans une fonction une variable peut être déclarée externe par l´écriture:
       extern x;
       x est connu dans toute fonction où figure la même déclaration extern x;
Remarques:
       rem var "x"; Supprime la variable x.
       name("x")="y"; Renomme la variable x en y.
       ini var; Supprime toutes les variables externes.

Variables statiques

       Des variables peuvent être déclarées statiques dans une fonction (c´est à dire inconnues à l´extérieur de la fonction mais conservant leurs valeurs à sa sortie) par l´écriture:
       static x;
Remarques:
       static x=1; Déclare x statique et l´initialise à 1
       static x=(1+2*PI/4); L´initialise à une valeur calculée

visibilité

Les variables déclarées extern, sont visibles de partout. Une bonne habitude pour les distinguer des autres variables est de faire commencer leur nom par une majuscule.
Les variables déclarées static dans une fonction ne sont visibles que dans cette fonction.
Les variables déclarées auto dans une fonction, ou non déclarées, ne sont visibles que dans cette fonction.
Les variables ne peuvent pas être confondues avec une commande puisque leur affectation donnerait alors lieu à une erreur.

Pointeurs

l´opérateur unaire @ retourne une adresse:
t=[0,5];p=@t; p est l´adresse de t, c´est un nombre:
       $p; imprime par exemple 100023824
alors que sa valeur est celle de t:
       $p[0,5]; imprime 0,1,2,3,4,5

Variables passées par adresse

Un paramètre formel peut être une adresse, il suffit de le déclarer address, l´appel se fait avec un @.
Exemple:
a(x)
address x;
{
       $x++;
}
x=1;for(i=1,3)a(@x);
imprime: (1.000000) (2.000000) (3.000000)

Variables de noms variables

var expr1
       Retourne l´évaluation de la variable de nom l´évaluation de expr1.
var expr1=expr2
       Donne à la variable de nom l´évaluation de expr1 la valeur de expr2.
Exemples: var("x",string 123)=-1; donne à la variable x123 la valeur -1
for(i=0,3)var("x",string i)=i; genere les 4 variables x0, x1, x2, x3 de valeurs respectives 0, 1, 2, 3.
for(i=0,3)$var("x", string i); imprime (0) (1) (2) (3)

Noms de fonctions passées en paramètres d´une fonction

       Si un paramètre formel est déclaré de type func tout de suite après le nom de la fonction et avant la 1ère { il pourra être appelé par un nom de commande ou de fonction placé entre guillemets.
Exemple:
Soit la fonction: toto(f,x)
       func f;
       {
       $f(x)
       }

       toto("cos",0); product 1.0
       toto("sin",0); product 0.0
Soit la fonction:
anyflo(f,v)
func f;
{
       $2*v+3;
}

toto("anyflo",3) product 7.0

var func "fff"

       Retourne la liste des noms des variables locales de la fonction fff.

FONCTIONS MATHÉMATIQUES

abs       acos       acosh       alea       arc       ascii       asin       asinh       atan       atanh       atof       atoi
string       stringf       cos       cosh
dist
ent       exp
inclu       input       int       inv
limit       log
max       min       module       average
precision       print       product       puls
radian       rand       rand2       rand2f       randf
scalar       sin       sinh       sum       sqrt       system
tan       tanh       time       sort
unit
vector

abs(expr): Retourne la valeur absolue de expr
Exemple:
       $abs(1-3); imprime 2

acos(expr): Retourne l´arc cosinus de expr
Exemple:
       $acos(.5); imprime 1.047198 c´est à dire PI/3

acosh(expr): Retourne l´arc cosinus hyperbolique de expr
Exemple:
       $acosh(10); imprime 2.993223

alea(n): Retourne l´aléatoire précalculé d´indice n.

arc(r,an,dan,n): Retourne la ligne polygonale régulière de rayon r, d´angle à l´origine an, d´ouverture dan et de n sommets
Exemple:
       edit(arc 100,0,PI/2,3); Produit
       100.0 0.0 0.0
       70.710678 70.710678 0.0
       0.0 100.0 0.0

ascii(expr): Retourne la chaîne de code ASCII expr
Exemple:
       $ascii[65,70]; imprime ABCDEF

asin(expr): Retourne l´arc sinus de expr
Exemple:
       $asin(1); imprime 1.570796 c´est à dire PI/2

asinh(expr): Retourne l´arc sinus hyperbolique de expr
Exemple:
       $asinh(10); imprime 2.998223

atan(expr): Retourne l´arc tangente de expr
Exemple:
       $atan(1); imprime 0.785398 c´est à dire PI/4

atanh(expr): Retourne l´arc tangente hyperbolique de expr
Exemple:
       $atanh(.5); imprime 0.549306

atof(expr): Retourne la valeur flottante de la chaîne expr
Exemple:
       $atof("12.34"); imprime 12.340000

atoi(expr): Retourne la valeur entière de expr
Exemple:
       x=atoi("123"); Donne à x la valeur 123.000000

string(expr): Retourne la chaîne exprimant l´entier expr
Exemple:
       $string(123); imprime la chaîne "123"

stringf(expr): Retourne la chaîne exprimant le flottant expr
Exemple:
       x=stringf(123,45); Donne à x la valeur "123.45"

cos(expr): Retourne le cosinus de expr
Exemple:
       $cos(PI/4); imprime 0.707107

cosh(expr): Retourne le cosinus hyperbolique de expr
Exemple:
       $cosh(10); imprime 11013.233398

dist(p1,p2): Retourne la distance des 2 points p1 et p2
Exemple:
       $dist(0,0,0,100,100,0); imprime 141.421356

ent(expr): Retourne l´entier le plus proche de expr
Exemple:
       $ent(12.34); imprime 12

exp(expr): Retourne l´exponentielle de expr
Exemple:
       $exp(2); imprime 7.389056

inclu(x,w): Retourne l´indice de x dans w et NIL si x n´est pas dans w
Exemples:
       $inclu(3,[1,5]); imprime 2
       $inclu(1,2,3,4); imprime NIL

input: Retourne l´évaluation de l´expression rentrée au clavier
Exemple:
       if(input!=NIL) $"OK"; imprime OK si on rentre 1 Ne product rien si on rentre ENTER

int(n): Retourne l´entier immédiatement inférieur à n
Exemple:
       int(1.1,1.9,2); retourne (1,1,2)

inv(expr): Retourne la ligne polygonale 3D inversée
Exemple:
       edit(inv[1,6]); Produit
       4 5 6
       1 2 3

limit(expr): Retourne le plus petit et le plus grand point de expr
Exemple:
       $limit[1,30]; imprime (1.0 2.0 3.0 28.0 29.0 30.0)

log(expr): Retourne le logarithme népérien de expr
Exemple:
       $log(10); imprime 2.302585

max(expr): Retourne le plus grand élément de expr
Exemple:
       $max[1,12]; imprime 12.0

min(expr): Retourne le plus petit élément de expr
Exemple:
       $min[1,12]; imprime 1.0

module(expr): Retourne le module de expr
Exemple:
       $module(100,200,300); imprime 374.165741

average(expr): Retourne la moyenne de expr
Exemple:
       $average[1,11]; imprime 6.0 < /a>

precision: Retourne la précision de l´opérateur ~ (0.1 par défaut)
precision(expr): Modifie la précision

print(expr) ou $(expr); imprime l´évaluation de expr

product(expr): Retourne le product des éléments de expr
Exemple:
       $product[1,6]; imprime 720 c´est à dire factorielle(6)

puls(x,x1,x2,p,e): Retourne x1+(x2-x1)*(1+sin(2*PI*x/p-PI/2))^e)/2
Exemple:
       $puls(.1,-1,1,0,0); imprime -0.809017

radian
Les angles s´expriment en radians: PI radians valent 180 degrés.

rand(expr): Retourne un aléatoire non reproductible entier de [0,expr[
Exemple:
       $rand(10,20); imprime par exemple (3.0 15.0)

rand2(exp1,exp2): Retourne un aléatoire non reproductible entier de [exp1,exp2]
Exemple:
       $rand2(10,20); imprime par exemple 12.0

rand2f(exp1,exp2): Retourne un flottant de [exp1,exp2]
Exemple:
       $rand2f(1,2); imprime par exemple 1.435683

randf(expr): Retourne un flottant aléatoire non reproductible de [0,expr[
Exemple:
       $randf(1); imprime par exemple 0.124699

scalar(v1,v2): Retourne le product scalar des vecteurs v1 et v2
Exemple:
       $scalar(1,2,3,4,5,6); imprime 32.0

sin(expr): Retourne le sinus de expr
Exemple:
       $sin(PI/2,PI); imprime (1.0 0.0)

sinh(expr): Retourne le sinus hyperbolique de expr
Exemple:
       $sinh(10); imprime 11013.232422

sum(expr): Retourne la somme des éléments de expr
Exemple:
       $sum[1,6]; imprime 21.0

sqrt(expr): Retourne la racine carrée de expr
Exemple:
       $sqrt(2); imprime 1.414214

system("commande"): Passe au système la chaîne "commande"
Exemple:
       system("date"); Produit la date

tan(expr): Retourne la tangente de expr
Exemple:
       $tan(PI/4); imprime 1.0

tanh(expr): Retourne la tangente hyperbolique de expr
Exemple:
       $tanh(.5); imprime 0.462117

time: Retourne le temps (en nombre de secondes) écoulé depuis le
lancement du programme

sort(expr): Retourne la liste expr triée par ordre croissant
Exemple:
       $sort(10,1,3,7); imprime (1.0 3.0 7.0 10.0)

unit(v): Retourne le vecteur unit du vecteur v
Exemple:
       $unitaite(100,200,300); imprime (0.267261 0.534522 0.801784)

vector(v1,v2): Retourne le product vector des vecteurs v1 et v2
Exemple:
       $vector(1,2,3,4,5,6); imprime (-3.0 6.0 -3.0)

LES ENTRÉES SORTIES

directes
formatées

input: retourne l´évaluation de l´expression rentrée au clavier.
print(expr); ou $(expr); imprime l´évaluation de expr.

Entrées sorties directes

       write(expr) name("A"); Gare dans le fichier A l´évaluation de expr
       x=read("A"); Donne à x le contenu du fichier A
Remarque:
       Si expr est une chaîne de caractères A est un fichier ASCII
       write(expr) ascii name("A"); Gare dans le fichier ASCII A l´expression ASCII de expr

Entrées sorties formatées

format("<descr>string")
       Convertit expr selon le descriptif descr dont le format est constitué d´une liste de caractères séparés par des virgules:
       *: format ignoré
       valeur numérique: Valeur forcée
       X: Valeur convertie
Exemple:
       x=" coordonnees 1.2 3.4\n coordonnees -1.2 10\n";
       y=format("<*,X,X,0.0>",x); Retourne le vecteur:
       (1.2,3.4,0.0,-1.2,10.0,0.0)