2  Les objets du calcul formel

2.1  Les nombres

Les nombres peuvent être exacts ou approchés. Les nombres exacts sont les constantes prédéfinies, les entiers, les fractions d’entiers et plus généralement toute expression ne contenant que des entiers et des constantes, comme sqrt(2)*e^(i*pi/3). Les nombres approchés sont notés avec la notation scientifique standard : partie entière suivie du point de séparation et partie fractionnaire (éventuellement suivie de e et d’un exposant). Par exemple, 2 est un entier exact, 2.0 est la version approchée du même entier; 1/2 est un rationnel, 0.5 est la version approchée du même rationnel. Xcas peut gérer des nombres entiers en précision arbitraire : essayez de taper 500! et comptez le nombre de chiffres de la réponse.

On passe d’une valeur exacte à une valeur approchée par evalf, on transforme une valeur approchée en un rationnel exact par exact Les calculs sont effectués en mode exact si tous les nombres qui interviennent sont exacts. Ils sont effectués en mode approché si un des nombres est approché. Ainsi 1.5+1 renvoie un nombre approché alors que 3/2+1 renvoie un nombre exact.

sqrt(2)
evalf(sqrt(2))
sqrt(2)-evalf(sqrt(2))
exact(evalf(sqrt(2)))*10^9
exact(evalf(sqrt(2)*10^9))

Pour les nombres réels approchés, la précision par défaut est proche de 14 chiffres significatifs (la précision relative est de 53 ou 45 bits pour les réels flottants normalisés selon les versions de Xcas). Elle peut être augmentée, en donnant le nombre de décimales désiré comme second argument de evalf.

evalf(sqrt(2),50)
evalf(pi,100)

On peut aussi changer la précision par défaut pour tous les calculs en modifiant la variable Digits.

Digits:=50
evalf(pi)
evalf(exp(pi*sqrt(163)))

La lettre i est réservée à √−1 et ne peut être réaffectée ; en particulier on ne peut pas l’utiliser comme indice de boucle.

(1+2*i)^2
(1+2*i)/(1-2*i)
e^(i*pi/3)

Xcas distingue l’infini non signé infinity (∞), de +infinity ou inf (+∞) et de -infinity ou -inf(−∞).

1/0; (1/0)^2; -(1/0)^2 

2.2  Les caractères et les chaînes

Une chaîne est parenthésée par des guillemets ("). Un caractère est une chaîne ayant un seul élément.

s:="azertyuiop"
size(s)
s[0]+s[3]+s[size(s)-1]
concat(s[0],concat(s[3],s[size(s)-1]))
head(s)
tail(s)
mid(s,3,2)
l:=asc(s)
ss:=char(l)
string(123)
expr(123)
expr(0123)

2.3  Les variables

On dit qu’une variable est formelle si elle ne contient aucune valeur : toutes les variables sont formelles tant qu’elles n’ont pas été affectées (à une valeur). L’affectation est notée :=. Au début de la session a est formelle, elle devient affectée après l’instruction a:=3, a sera alors remplacé par 3 dans tous les calculs qui suivent, et a+1 renverra 4. Xcas conserve tout le contenu de votre session. Si vous voulez que la variable a après l’avoir affectée, soit à nouveau une variable formelle, il faut la "vider" par purge(a). Dans les exemples qui suivent, les variables utilisées sont supposées avoir été purgées avant chaque suite de commandes. Il ne faut pas confondre

• le signe := qui désigne l’affectation
• le signe == qui désigne une égalité booléenne : c’est une opération binaire qui retourne 1 ou 0 (1 pour true qui veut dire Vrai et 0 pour false qui veut dire Faux)
• le signe = utilisé pour définir une équation.

a==b
a:=b
a==b
solve(a=b,a)
solve(2*a=b+1,a)

On peut faire certains types d’hypothèses sur une variable avec la commande assume, par exemple assume(a>2). Une hypothèse est une forme spéciale d’affectation, elle efface une éventuelle valeur précédemment affectée à la variable. Lors d’un calcul, la variable n’est pas remplacée mais l’hypothèse sera utilisée dans la mesure du possible, par exemple abs(a) renverra a si on fait l’hypothèse a>2.

sqrt(a^2)
assume(a<0)
sqrt(a^2)
assume(n,integer)
sin(n*pi)

La fonction subst permet de remplacer une variable dans une expression par un nombre ou une autre expression, sans affecter cette variable.

subst(a^2+1,a=1)
subst(a^2+1,a=sqrt(b-1))
a^2+1

Remarque : pour stocker une valeur dans une variable par référence, par exemple pour modifier une valeur dans une liste (un vecteur, une matrice), sans recréer une nouvelle liste mais en modifiant en place la liste existante, on utilise l’instruction =< au lieu de :=. Cette instruction est plus rapide que l’instruction :=, car elle économise le temps de copie de la liste.

2.4  Les expressions

Une expression est une combinaison de nombres et de variables reliés entre eux par des opérations : par exemple x^2+2*x+c.

Lorsqu’on valide une commande, Xcas remplace les variables par leur valeur si elles en ont une, et exécute les opérations.

(a-2)*x^2+a*x+1
a:=2
(a-2)*x^2+a*x+1

Certaines opérations de simplification sont exécutées automatiquement lors d’une évaluation :

• les opérations sur les entiers et sur les fractions, y compris la mise sous forme irréductible
• les simplifications triviales comme x+0=x, x−x=0, x¹=x…
• quelques formes trigonométriques comme cos(−x)=cos(x), cos(π/4)=√2/2, tan(π/4)=1…

Nous verrons dans la section suivante comment obtenir plus de simplifications.

2.5  Développer et simplifier

En-dehors des règles de la section précédente, il n’y a pas de simplification systématique. Il y a deux raisons à cela. La première est que les simplifications non triviales sont parfois coûteuses en temps, et le choix d’en faire ou non est laissé à l’utilisateur ; la deuxième est qu’il y a en général plusieurs manières de simplifier une même expression, selon l’usage que l’on veut en faire. Les principales commandes pour transformer une expression sont les suivantes :

• expand : développe une expression en tenant compte uniquement de la distributivité de la multiplication sur l’addition et du développement des puissances entières.
• normal et ratnormal : d’un bon rapport temps d’exécution-simplification, elles écrivent une fraction rationnelle (rapport de deux polynômes) sous forme de fraction irréductible développée; normal tient compte des nombres algébriques (par exemple comme sqrt(2)) mais pas ratnormal. Les deux ne tiennent pas compte des relations entre fonctions transcendantes (par exemple comme sin et cos).
• factor : un peu plus lente que les précédentes, elle écrit une fraction sous forme irréductible factorisée.
• simplify : elle essaie de se ramener à des variables algébriquement indépendantes avant d’appliquer normal. Ceci est plus coûteux en temps et "aveugle" (on ne contrôle pas les réécritures intermédiaires). Les simplifications faisant intervenir des extensions algébriques (par exemple des racines carrées) nécessitent parfois deux appels et/ou des hypothèses (assume) pour enlever des valeurs absolues avant d’obtenir la simplification souhaitée.
• tsimplify essaie de se ramener à des variables algébriquement indépendantes mais sans appliquer normal ensuite.

Dans le menu Expression du bandeau supérieur, les sous-menus sont des menus de réécriture et contiennent d’autres fonctions, pour des transformations plus ou moins spécialisées.

b:=sqrt(1-a^2)/sqrt(1-a)
ratnormal(b)
normal(b)
tsimplify(b)
simplify(b)
simplify(simplify(b))
assume(a<1)
simplify(b)   
simplify(simplify(b))

La fonction convert permet de passer d’une expression à une autre équivalente, sous un format qui est spécifié par le deuxième argument.

convert(exp(i*x),sincos)
convert(1/(x^4-1),partfrac)
convert(series(sin(x),x=0,6),polynom)

2.6  Les fonctions

De nombreuses fonctions sont déjà définies dans Xcas, en particulier les fonctions classiques. Les plus courantes figurent dans le tableau ci-après; pour les autres, voir le menu Cmds->Reel->Special.
Sinon l’utilisateur peut définir ses propre fonctions, par exemple :

• Définition d’une fonction d’une variable :
  f(x):=x*exp(x) ou
  f:=x->x*exp(x) ou
  f:=unapply(x*exp(x),x)
• Définition de sa dérivée :
  g:=function_diff(f) ou
  g:=unapply(diff(f(x),x),x))
  ATTENTION g(x):=diff(f(x),x) N’EST PAS VALABLE ! car ce qui est à droite de := n’est pas évalué lors de la définition....il faut utiliser unapply.
• Définition d’une fonction de 2 variables :
  h(r,t):=(r*exp(t),r*t) ou
  h:=(r,t)->(r*exp(t),r*t);
• Définition à partir d’une fonction de 2 variables, d’une fonction qui à 1 variable fait correspondre une fonction:
  k(t):=unapply(h(r,t),r)
  ATTENTION Ici k(t) est une fonction de la variable r qui à r fait correspondre h(r,t). On a par exemple : k(1)(2)=(2*exp(1),2). Là aussi, il faut utiliser unapply.

Pour créer une nouvelle fonction, il faut la déclarer à l’aide d’une expression contenant la variable. Par exemple l’expression x²−1 est définie par x^2-1. Pour la transformer en la fonction f qui à x associe x²−1, trois possibilités existent :

f(x):= x^2-1
f:=x->x^2-1
f:=unapply(x^2-1,x)

f(2); 
f(a^2);

Si f est une fonction d’une variable et E est une expression, f(E) est une autre expression. Il est essentiel de ne pas confondre fonction et expression. Si on définit : E:=x^2-1, alors la variable E contient l’expression x²−1. Pour avoir la valeur de cette expression en x=2 il faut écrire subst(E,x=2) et non E(2) car E n’est pas une fonction. Lorsqu’on définit une fonction, le membre de droite de l’affectation n’est pas évalué. Ainsi l’écriture E:=x^2-1; f(x):=E définit la fonction f: x ↦ E car E n’est pas évalué. Par contre E:= x^2-1; f:=unapply(E,x) définit bien la fonction f: x↦ x²−1 car E est évalué.

On peut ajouter et multiplier des fonctions, par exemple f:=sin*exp. Pour composer des fonctions, on utilise l’opérateur @ et pour composer plusieurs fois une fonction avec elle-même, on utilise l’opérateur @@.

f:=x->x^2-1;
(f@f)(2);
(f@sqrt)(a);
f1:=f@sin
f2:=f@f
f3:=f@@3
f1(a)
f2(a)
f3(a)

On peut définir des fonctions de plusieurs variables à valeurs dans ℝ comme :
f(x,y):=x+2*y
et des fonctions de plusieurs variables à valeurs dans ℝ^p par exemple :
f(x,y):=(x+2*y,x-y)

2.7  Listes, séquences, ensembles

Xcas distingue plusieurs sortes de collections d’objets, séparés par des virgules :

• les listes (entre crochets)
• les séquences (entre parenthèses)
• les ensembles (entre pourcentage-accolades)

liste:=[1,2,4,2]
sequence:=(1,2,4,2)
ensemble:=%{1,2,4,2%}

Les listes peuvent contenir des listes (c’est le cas des matrices), alors que les séquences sont plates (un élément d’une séquence ne peut pas être une séquence). Dans un ensemble, l’ordre n’a pas d’importance et chaque objet est unique. Il existe une autre structure, appelée table, dont nous reparlerons plus loin.

Il suffit de mettre une séquence entre crochets pour en faire une liste ou entre accolades précédées de % pour en faire un ensemble. On passe d’une liste à sa séquence associée par op, d’une séquence à sa liste associée en la mettant entre crochets ou avec la fonction nop. Le nombre d’éléments d’une liste est donné par size (ou nops).

se:=(1,2,4,2)
li:=[se]
op(li)
nop(se)
nops(se)
%{se%}
size([se])
size(%{se%})

Pour fabriquer une liste ou une séquence, on utilise des commandes d’itération comme $ ou seq (qui itèrent une expression) ou makelist (qui définit une liste à l’aide d’une fonction).

1$5
k^2 $ (k=-2..2)
seq(k^2,k=-2..2)
seq(k^2,k,-2..2)
[k^2$(k=-2..2)]
seq(k^2,k,-2,2)
seq(k^2,k,-2,2,2)
makelist(x->x^2,-2,2)
seq(k^2,k,-2,2,2)
makelist(x->x^2,-2,2,2)

La séquence vide est notée NULL, la liste vide []. Pour ajouter un élément à une séquence il suffit d’écrire la séquence et l’élément séparés par une virgule. Pour ajouter un élément à une liste on utilise append. On accède à un élément d’une liste ou d’une séquence grâce à son indice mis entre crochets, le premier élément étant d’indice 0.

se:=NULL; se:=se,k^2$(k=-2..2); se:=se,1
li:=[1,2]; (li:=append(li,k^2))$(k=-2..2)
li[0],li[1],li[2]

Les polynômes sont souvent définis par une expression, mais ils peuvent aussi être représentés par la liste de leurs coefficients par ordre de degré décroissant, avec comme délimiteurs poly1[ et ]. Il existe aussi une représentation pour les polynômes à plusieurs variables. Les fonctions symb2poly et poly2symb permettent de passer de la représentation expression à la représentation par liste et inversement, le deuxième argument détermine s’il s’agit de polynômes en une variable (on met le nom de la variable) ou de polynômes à plusieurs variables (on met la liste des variables).

2.8  Temps de calcul, place mémoire

Le principal problème du calcul formel est la complexité des calculs intermédiaires. Elle se traduit à la fois par le temps nécessaire à l’exécution des commandes et par la place mémoire requise. Les algorithmes implémentés dans les fonctions de Xcas sont performants, mais ils ne peuvent pas être optimaux dans tous les cas. La fonction time permet de connaître le temps d’exécution d’une commande (si ce temps est très court, Xcas exécute plusieurs fois la commande pour afficher un résultat plus précis). La mémoire utilisée apparaît dans les versions Unix dans la ligne d’état (la barre-bouton). Si le temps d’exécution d’une commande dépasse quelques secondes, il est possible que vous ayez commis une erreur de saisie. N’hésitez pas à interrompre l’exécution (bouton rouge STOP en haut à droite, il est conseillé de faire une sauvegarde de votre session auparavant).