GÉNÉRALITÉS
La syntaxe du langage ANYFLO reprend celle, bien connue, du langage C,
avec des simplifications et des extensions:
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
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
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
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
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:
définir la fonction f par:
f(x,y){$x,y;NL;}
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
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
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).
L´é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(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
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)