Les objets du calcul formel

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 est 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 d'environ 15 chiffres significatifs (précision relative de 53 bits pour les réels normalisés). Elle peut être changé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 à $ \sqrt{-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 ($ \infty$), de +infinity ($ +\infty$) et de -infinity ($ -\infty$).
1/0; (1/0)^2; -(1/0)^2
Constantes prédéfinies
pi $ \pi\simeq 3.14159265359$
e $ \mathrm{e}\simeq 2.71828182846$
i $ \mathrm{i}=\sqrt{-1}$
infinity $ \infty$
+infinity $ +\infty$
-infinity $ -\infty$
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, redevienne 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
$ \bullet$
le signe := qui désigne l'affectation
$ \bullet$
le signe == qui désigne une égalité booléenne : c'est une opération binaire qui retourne 1 pour Vrai ou 0 pour Faux)
$ \bullet$
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
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 :
$ \bullet$
les opérations sur les entiers et sur les fractions, y compris la mise sous forme irréductible
$ \bullet$
les simplifications triviales comme $ x+0=x$, $ x-x=0$, $ x^1=x$...
$ \bullet$
quelques formes trigonométriques : $ \cos(-x)=\cos(x)$, $ \tan(\pi/4)=1$...
Nous verrons dans la section suivante comment obtenir plus de simplifications. 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 :
$ \bullet$
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.
$ \bullet$
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).
$ \bullet$
factor : un peu plus lente que les précédentes, elle écrit une fraction sous forme irréductible factorisée.
$ \bullet$
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.
$ \bullet$
tsimplify essaie de se ramener à des variables algébriquement indépendantes mais sans appliquer normal ensuite.
Dans le menu Math du bandeau supérieur, les 4 sous-menus de récriture 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)
Transformations
simplify simplifier
tsimplify simplifier (moins puissant)
normal forme normale
ratnormal forme normale (moins puissant)
expand développer
factor factoriser
assume rajout d'hypothèses
convert transformer en un format spécifié
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 Math.
Fonctions classiques
abs valeur absolue
round arrondi
floor partie entière (plus grand entier $ \leqslant$)
ceil plus petit entier $ \geqslant $
abs module
arg argument
conj conjugué
sqrt racine carrée
exp exponentielle
log logarithme naturel
ln logarithme naturel
log10 logarithme en base 10
sin sinus
cos cosinus
tan tangente
asin arc sinus
acos arc cosinus
atan arc tangente
sinh sinus hyperbolique
cosh cosinus hyperbolique
tanh tangente hyperbolique
asinh argument sinus hyperbolique
acosh argument cosinus hyperbolique
atanh argument tangente hyperbolique
Pour créer une nouvelle fonction, il faut la déclarer à l'aide d'une expression contenant la variable. Par exemple l'expression $ x^2-1$ est définie par x^2-1. Pour la transformer en la fonction $ f$ qui à $ x$ associe $ x^2-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^2-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 \mapsto E$. Par contre E:= x^2-1; f:=unapply(E,x) définit bien la fonction $ f: x\mapsto x^2-1$.

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
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 $ \mathbb{R}$ comme
f(x,y):=x+2*y et des fonctions de plusieurs variables à valeurs dans $ \mathbb{R}^p$ par exemple : f(x,y):=(x+2*y,x-y).

Listes, séquences, ensembles Xcas distingue plusieurs sortes de collections d'objets, séparés par des virgules :

$ \bullet$
les listes (entre crochets)
$ \bullet$
les séquences (entre parenthèses)
$ \bullet$
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 par nop. Le nombre d'éléments d'une liste est donné par size.

se:=(1,2,4,2)
li:=[se]
op(li)
nop(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 []. Il suffit d'écrire à la suite une séquence, puis une virgule, puis une autre séquence pour les concaténer. 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 %[ 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).

Séquences et listes
E$(k=n..m) créer une séquence
seq(E,k=n..m) créer une séquence
[E$(k=n..m)] créer une liste
makelist(f,k,n,m,p) créer une liste
op(li) passer de liste à séquence
nop(se) passer de séquence à liste
size(li) nombre d'éléments
sum somme des éléments
product produit des éléments
cumSum sommes cumulées des éléments
apply(f,li) appliquer une fonction à une liste
map(li,f) appliquer une fonction à une liste
poly2symb polynôme associé à une liste
symb2poly coefficients d'un polynôme
Les chaînes de caractères Une chaîne de caractères est encadrée par des doubles quotes ("). Un caractère est une chaîne ayant un seul élément. Il est possible de fabriquer des chaînes par extraction de parties et concaténation. Il est aussi possible de transformer une chaîne en expression et inversement.
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)
Chaînes de caractères
size nombre de caractères
concat ou + concaténation
mid morceau de chaîne
head premier caractère
tail chaîne sans le premier caractère
string nombre ou expression transformé en chaîne
expr chaîne transformée en nombre ou expression
asc chaîne transformée en liste de codes ASCII
char liste de codes ASCII transformée en chaîne
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 (en rouge à bas à gauche). 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 orange stop en bas à droite, il est conseillé de faire une sauvegarde de votre session auparavant).


         © UJF Grenoble, 2011                              Mentions légales