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 , , ...
$\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

est définie par x^2-1. Pour la transformer en la fonction

qui à

associe

, 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

. Pour avoir la valeur de cette expression en

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).