### 6.13.1 Qu’est-ce qune expression

Il ne faut pas confondre expression et fonction.
Une expression est une combinaison de nombres et de variables reliés par des opérations alors qu’une fonction associe à une variable une expression.
Par exemple :
`a:=x^2+2*x+1` définit une expression et `b(x):=x^2+2*x+1` définit une fonction.
On obtient la valeur de l’expression `a` en 0, avec `subst(a,x=0)` et la valeur de la fonction `b` en 0, avec `b(0)`.
On peut aussi considérer une expression comme un arbre.
Par exemple, si `A:=3+2*x/y` ou si `B:=sin(2x+3)` on a :

- le sommet de l’arbre `A` est l’opérateur `’+’` et le sommet de l’arbre `B` est la fonction `’sin’`.
  On a :
  `sommet(A)` renvoie `’+’`
  `sommet(B)` renvoie `’sin’`
- les feuilles de l’arbre `A` sont `3,2*x/y` (car `’+’` est un opérateur binaire) et la feuille de l’arbre `B` est `2*x+3` (car `’sin’` est une fonction d’une variable).
  On a :
  `feuille(A)` renvoie `3,2*x/y`
  `feuille(B)` renvoie `2*x+3`
- la feuille `2*x/y` est elle-même un arbre de sommet `’*’` etc...
- Les variables `A` et `B` permettent de retrouver la structure d’arbre en effet :
  `A[0],A[1],A[2],A[2,0],A[2,1],A[2,2],A[2,3],A[2,3,0],A[2,3,1]`
  renvoie : `’+’,3,2*x,’*’,2,x,1/y,’inv’,y`
  `B[0],B[1,0],B[1,1],B[1,2],B[1,1,0],B[1,1,1],B[1,1,2]`
  renvoie : `’sin’,’+’,2*x,3,’*’,2,x`

Attention
Si `C:=2*x-y` alors
`sommet(C)` renvoie `’+’` et
`feuille(C)` renvoie `2*x,-y`
car l’expression est `C` s’écrit `2*x+(-y)`
De même si `D:=x/3` alors
`sommet(D)` renvoie `’*’` et
`feuille(C)` renvoie `x,1/3`
car l’expression est `D` s’écrit `x*1/3`
On a alors :
`C[0],C[1],C[1,0],C[1,1],C[1,2],C[2],,C[2,0],C[2,1]`
renvoie : `’+’,2*x,’*’,2,x,-y,’-’,y` (`’-’` est le "moins" unaire).
Et :
`D[0],D[1],D[2],D[2,0],D[2,1],B[1,1,2]`
renvoie : `’*’,x,1/3,’inv’,3`
Remarque
Ce qui suit n’est valable que pour des programmeurs confirmés avec les manipulations qui suivent, les erreurs sont faciles !
On peut changer le sommet ou une feuille terminale en affectant l’une des variables `A[0],A[1],A[2],A[2,0],A[2,1],A[2,2],A[2,3],A[2,3,0],A[2,3,1]`
ou `B[0],B[1,0],B[1,1],B[1,2],B[1,1,0],B[1,1,1],B[1,1,2]`
MAIS il faut faire cela avec prudence car le système ne fait pas de vérifications et n’enverra pas de message d’erreurs.
On tape :
`A:=3+2*x/y`
`A[0]:=’*’` Et `A` renvoie `6*x/y` Maintenant :`A[1]` renvoie `6`
On peut taper :
`A[1]:=2+z` Maintenant `A` renvoie `(2+z)*x/y`
On tape :
`B:=sin(2*x+3)`
`B[0]:=cos` Et `B` renvoie `cos(2*x+3)` Puis, on tape :
`B[1,2]:=y` et `B` renvoie `cos(2*x+y)`