Syntaxe
expr Arg?Arg Arg...?
Description
Les arguments Arg sont r´eunis en une seule expression, s´epar´es par une espace les uns des autres, et cette expression est ´evalu´ee: elle renvoie presque toujours une valeur num´erique (enti`ere ou en virgule fottante). L’expression contient en principe des op´erateurs, des op´erandes et ´eventuellement des parenth`eses. La syntaxe des expressions autoris´ees est analogue `a celle des expressions du langage C mais Tcl supporte en plus des op´erandes non num´eriques et peut faire des comparaisons de chaˆınes. Pour qu’une valeur ou une op´eration soient trait´ees en virgule flottante, il faut que l’un des nombres soit not´e avec un point d´ecimal. Par exemple, les trois expressions suivantes
expr 8 / 3 expr 8.0 / 3 expr 8.2 + 3
renvoient les valeurs 2, 2.66667 et 11.2 respectivement. Les valeurs en virgule flot- tante sont toujours renvoy´ees avec un point mˆeme si le r´esultat est entier.
Op´erandes
Les op´erandes, op´erateurs et parenth`eses peuvent ˆetre s´epar´es par des espaces : celles-ci seront de toutes fa¸con ignor´ees par l’interpr´eteur. Partout o`u c’est possible les op´erandes sont interpr´et´es comme des nombres entiers. Les entiers peuvent ˆetre exprim´es en notation d´ecimale (c’est le cas ordinaire), en notation octale (si le premier caract`ere est un 0) ou en notation hexad´ecimale (les deux premiers caract`eres sont 0x).
Dans les autres cas, l’op´erateur sera trait´e, si possible, comme nombre en vir- gule flottante. Les notations usuelles du langage C norme ansi sont accept´ees (les suffixes f, F, l et L ne sont toutefois pas autoris´es). Par exemple : 2.1, 3., 6e4, 7.91e+16.
Si aucune des interpr´etations pr´ec´edentes n’est possible alors l’op´erande est consid´er´e comme une chaˆıne de caract`eres et seulement un nombre limit´e d’op´erations peuvent lui ˆetre appliqu´ees.
On peut sp´ecifier les op´erandes de plusieurs fa¸cons :
– comme valeur num´erique enti`ere ou en virgule flottante comme vu pr´ec´edem- ment.
– comme une variable Tcl en utilisant la notation standard avec le symbole dollar $ pour d´esigner sa valeur.
. expr 58 – comme une chaˆıne plac´ee entre guillemets doubles. L’interpr´eteur effectuera les interpolations de variables et substitutions de commandes de la chaˆıne pass´ee entre les guillemets et utilisera le r´esultat comme op´erande.
– comme une chaˆıne plac´ee entre accolades{ }. L’interpr´eteur n’effectue aucune interpolation ou substitution.
– comme une instruction Tcl plac´ee entre crochets. Cette commande imbriqu´ee sera ex´ecut´ee et c’est son r´esultat qui sera utilis´e comme op´erande.
– comme une fonction math´ematique dont les arguments prennent une des formes qui viennent d’ˆetre mentionn´ees comme par exemple sin($x).
Op´erateurs
Les op´erateurs admis par la commande expr sont :
- + ~ !
Op´erateurs unaires moins, plus, NON bit-`a-bit, NON logique. Aucun de ces op´erandes ne peut ˆetre appliqu´e `a des chaˆınes et l’op´erateur de NON bit-`a-bit ne s’applique qu’`a des op´erandes entiers.
* / %
Multiplications, divisions et restes. Aucun de ces op´erandes ne peut ˆetre ap- pliqu´e `a des chaˆınes et l’op´erateur de reste ne s’applique qu’`a des op´erandes entiers. Le reste a toujours le mˆeme signe que le diviseur.
+ -
Addition et soustraction. Applicable seulement `a des op´erandes num´eriques.
¡¡ ¿¿
D´ecalage des bits `a gauche ou `a droite. Applicable seulement `a des op´erandes num´eriques. Le d´ecalage `a droite propage toujours le bit de signe.
¡ ¿ ¡= ¿=
Inf´erieur, sup´erieur, inf´erieur ou ´egal, sup´erieur ou ´egal. Ils fonctionnent comme des op´erateurs logiques et renvoient 1 si la relation d’ordre est v´erifi´ee, 0 sinon. On peut ´egalement les appliquer `a des chaˆınes : les comparaisons de chaˆınes sont alors employ´ees.
== !=
´
Egalit´e et diff´erence. Ils renvoient 1 si la relation d’´egalit´e est v´erifi´ee, 0 sinon. Applicables `a tous les types.
eq ne
´
Egalit´e et diff´erence pour des chaˆınes. ils renvoient 1 si la relation d’´egalit´e est v´erifi´ee, 0 sinon. Les op´erandes ne peuvent ˆetre que des chaˆınes. Ces op´erateurs ont ´et´e introduits avec la version 8.4 de Tcl.
&
ET bit-`a-bit. Applicable uniquement `a des entiers. ˆ
OU exclusif bit-`a-bit. Applicable uniquement `a des entiers. —
abs ceil floor log sin
acos cosh fmod pow sqrt
asin cos hypot rand srand
atan2 double int round tanh
atan exp log10 sinh tan
Tab. 4 – Fonctions math´ematiques support´ees par la commande expr de Tcl. &&
ET logique. Renvoie 1 si les deux op´erandes sont non-nuls, 0 sinon. Applicable uniquement `a des valeurs num´eriques ou bool´eennes.
——
OU logique. Renvoie 0 si les deux op´erandes sont nuls, 1 sinon. Applicable uniquement `a des valeurs num´eriques ou bool´eennes.
x? y : z
C’est l’instruction if-then-else du langage C. Si x est ´evalu´e `a une valeur non nulle, alors le r´esultat sera la valeur de y. Sinon ce sera celle de z. L’op´erande x doit avoir une valeur num´erique.
Les r`egles de pr´ec´edence sont les mˆemes que celles qui sont en usage dans le langage C. Les op´erateurs &&, —— et ?: sont dits paresseux : leurs op´erandes ne sont ´evalu´es que si n´ecessaire. Par exemple, dans l’expression
expr {$v ? [a] : [b]}
seulement la commande imbriqu´ee [a] ou [b] sera effectivement ´evalu´ee selon la valeur de $v. Ceci n’est vrai cependant que si l’expression est entour´ee d’accolades, sinon l’interpr´eteur Tcl lui-mˆeme aura d´ej`a substitu´e [a] et [b] avant mˆeme qu’ils ne soient trait´es par expr.
Fonctions math´ematiques
Tcl supporte les fonctions math´ematiques r´eunies dans le tableau4. Leur signi- fication est la suivante :
abs(Arg)
Renvoie la valeur absolue de Arg. Arg peut ˆetre un entier ou un nombre en virgule flottante et le r´esultat est renvoy´e dans le mˆeme type.
acos(Arg)
Renvoie l’arc cosinus de Arg dans l’intervalle [0,π] radians. Arg doit appartenir `a l’intervalle [−1,1].
asin(Arg)
Renvoie l’arc sinus de Arg dans l’intervalle [−π/2,π/2] radians. Arg doit ap- partenir `a l’intervalle [−1,1].
atan(Arg)
. expr 60 atan2(x, y)
Renvoie l’arc tangente de y/x dans l’intervalle [−π,π] radians. x et y doivent ˆetre non nuls.
ceil(Arg)
Renvoie le plus petit entier sup´erieur ou ´egal `a Arg. cos(Arg)
Renvoie le cosinus de Arg (Arg est exprim´e en radians). cosh(Arg)
Renvoie le cosinus hyperbolique de Arg. Si le r´esultat provoque un d´epassement de capacit´e, une erreur est g´en´er´ee.
double(Arg)
Si Arg est une valeur en virgule flottante, renvoie Arg, sinon convertit Arg en virgule flottante et renvoie la valeur obtenue.
exp(Arg)
Renvoie l’exponentielle de Arg d´efinie comme eArg. Si le r´esultat provoque
un d´epassement de capacit´e, une erreur est g´en´er´ee. floor(Arg)
Renvoie le plus grand entier inf´erieur ou ´egal `a Arg. fmod(x, y)
Renvoie le reste en virgule flottante de la division de x par y. Si y est nul une erreur est g´en´er´ee.
hypot(x, y)
Calcule la longueur de l’hypot´enuse d’un triangle rectangle de cˆot´es x et y (normepx2+ y2du vecteur (x,y)).
int(Arg)
Si Arg est un entier, renvoie Arg, sinon convertit Arg `a une valeur enti`ere en le tronquant et renvoie la valeur obtenue. Attention, ce n’est pas la fonction partie enti`ere : expr int(-3.5) renvoie -3 et non pas -4.
log(Arg)
Renvoie le logarithme n´ep´erien de Arg. Arg doit ˆetre strictement positif. log10(Arg)
Renvoie le logarithme en base 10 de Arg. Arg doit ˆetre strictement positif. pow(x, y)
Calcule la valeur xy de x ´elev´e `a la puissance y. Si x est n´egatif alors y doit
ˆetre entier. rand()
Renvoie un nombre al´eatoire dans l’intervalle [0,1[ (1 exclu). Le germe de cette fonction al´eatoire est pris `a l’horloge interne de la machine ou peut ˆetre fix´e au moyen de la fonction srand.
round(Arg)
Si Arg est entier, renvoie Arg, sinon arrondit Arg `a une valeur enti`ere et renvoie cette valeur. Par exemple,
expr round(3.5)
renvoient respectivement 3 et 4. sin(Arg)
Renvoie le sinus de Arg (Arg est exprim´e en radians). sinh(Arg)
Renvoie le sinus hyperbolique de Arg. Si le r´esultat provoque un d´epassement de capacit´e, une erreur est g´en´er´ee.
sqrt(Arg)
Renvoie la racine carr´ee de Arg. Arg doit ˆetre n´egatif ou nul. srand(Arg)
L’argument Arg doit ˆetre entier et sera utilis´e pour servir de germe `a la fonction rand() qui engendre des nombres al´eatoires. La valeur de retour est le premier nombre al´eatoire engendr´e `a partir de cette valeur.
tan(Arg)
Renvoie la tangente de Arg (Arg est exprim´e en radians). tanh(Arg)
Renvoie la tangente hyperbolique de Arg.
Types, capacit´e et pr´ecision
Tous les calculs internes mettant en jeu des valeurs enti`eres sont effectu´es avec le type long du langage C ; ceux qui mettent en jeu des nombres en virgule flottante sont faits avec le type double. Lors de la conversion d’une chaˆıne `a une valeur en vir- gule flottante les d´epassements d’exposant sont d´etect´es et provoquent une erreur. Pour la conversion de chaˆınes en valeurs enti`eres, la d´etection des d´epassements arithm´etiques d´epend du comportement de certaines routines de la biblioth`eque C locale, elle n’est donc pas fiable. Dans tous les cas, les d´epassements ou les valeurs trop faibles dans les calculs interm´ediaires en valeurs enti`eres ne sont pas non plus d´etect´es de mani`ere fiable. Dans le cas des calculs en virgule flottante, ils sont d´etect´es au mˆeme degr´e qu’ils le sont au niveau du mat´eriel ce qui est en g´en´eral suffisamment fiable.
Les conversions entre les repr´esentations internes des entiers, nombres en virgule flottante et chaˆınes se font automatiquement en fonction des besoins. De mani`ere g´en´erale, les calculs sont men´es en nombres entiers tant qu’un nombre en virgule flottante n’est pas rencontr´e; `a partir de l`a ils se poursuivront en virgule flottante. Par exemple,
expr 5 / 4
renvoie 1, tandis que les expressions expr 5 / 4.0
expr 5 / ( [string length "abcd"] + 0.0 )
renvoient toutes les deux 1,25. Les valeurs calcul´ees en virgule flottante sont tou- jours renvoy´ees avec un point d´ecimal ou bien avec une lettre e d’exposant pour qu’on ne les confonde pas avec des valeurs enti`eres. Par exemple,
. expr 62 renvoie 4,0 et non pas simplement 4.