Outils pour l'analyse

Dérivées La fonction diff permet de calculer la dérivée d'une expression par rapport à une ou plusieurs de ses variables. Pour dériver une fonction $f$, on peut appliquer diff à l'expression $f(x)$, mais alors le résultat est une expression. Si on souhaite définir la fonction dérivée, il faut utiliser function_diff.

E:=x^2-1
diff(E)
f:=unapply(E,x)
diff(f(x))
f1:=function_diff(f)

Il ne faut pas définir la fonction dérivée par f1(x):=diff(f(x)), car x aurait dans cette définition deux sens incompatibles : c'est d'une part la variable formelle de dérivation et d'autre part l'argument de la fonction f1. D'autre part, cette définition évaluerait diff à chaque appel de la fonction, ce qui serait inefficace (dans la définition d'une fonction le membre de droite n'est pasévalué). Il faut donc soit utiliser f1:=function_diff(f), soit f1:=unapply(diff(f(x)),x).

La fonction diff s'applique à n'importe quelle combinaison de variables, et permet de calculer des dérivées partielles successives.

E:=sin(x*y)
diff(E,x)
diff(E,y)
diff(E,x,y)-diff(E,y,x)
simplify(ans())
diff(E,x$2,y$3)

Si le deuxième argument de diff est une liste, une liste de dérivées est retournée. Par exemple pour calculer le gradient de $\sin(xy)$ : diff(sin(x*y),[x,y]) (on peut aussi utiliser grad). Des commandes particulières permettent de calculer les combinaisons classiques de dérivées partielles.

Dérivées
diff(ex)	dérivée d'une expression
function_diff(f)	dérivée d'une fonction
diff(ex,x$n,y$m)	dérivées partielles
grad	gradient
divergence	divergence
curl	rotationnel
laplacian	laplacien
hessian	matrice hessienne

Limites et développements limités La fonction limit calcule les limites finies ou infinies, quand elles existent. On peut demander une limite à gauche ou à droite à l'aide d'un quatrième argument ($+1$ ou $-1$). Quand la fonction dépend d'un paramètre, la limite obtenue peut dépendre des hypothèses faites, avec la fonction assume, sur ce paramètre.

limit(1/x,x,0)
limit(1/x,x,0,1)
limit(1/x,x,0,-1)
limit(a/x,x,0,1)
assume(a>0)
limit(a/x,x,0,1)

Pour les développements limités, deux fonctions sont disponibles, series et taylor. La différence est que l'ordre du développement doit être spécifié pour series, il est égal à 6 par défaut pour taylor.

L'ordre demandé est celui utilisé par Xcas en interne pour faire ses développements. En cas de simplifications, l'ordre du développement obtenu pourra être inférieur, il faudra alors recommencer le calcul avec un ordre plus grand. L'expression retournée est constituée du polynôme de Taylor, plus un reste sous la forme x^a*order_size(x), où x^a*order_size(x) est une fonction bornée. Pour supprimer le reste et ne garder que le polynôme de Taylor, on peut utiliser convert avec l'option polynom.

taylor(1/(x^2+1),x=0)
taylor(1/(x^2+a^2),x=0)
series(1/(x^2+1),0,11)
series(1/(x^2+1),+infinity,11)
series(tan(x),pi/4,3)
series(sin(x)^3/((1-cos(x))*tan(x)),0,4)
series(sin(x)^3/((1-cos(x))*tan(x)),0,6)
series(tan(sin(x))-sin(tan(x)),0,13)
convert(ans(),polynom)
series(f(x),0,3)
g:=f@f; series(g(x),0,2)

Limites et développements limités
limit(ex,x,a)	limite en a
limit(ex,x,a,1)	limite à droite en a
limit(ex,x,a,-1)	limite à gauche en a
taylor(ex,x=a)	développement limité en $a$ ordre 6
series(ex,x=a,n)	développement limité en $a$ ordre $n$

Primitives et intégrales La fonction int calcule une primitive d'une expression par rapport à $x$ ou par rapport à la variable donnée en argument. Si l'expression comporte d'autres variables que $x$, il faut préciser la variable d'intégration. Si on ajoute deux arguments $a$ et $b$ après la variable d'intégration, on calcule l'intégrale sur l'intervalle $[a,b]$. Eventuellement les bornes de l'intégrale peuvent être des expressions, ce qui permet de calculer des intégrales multiples.

int(x^2-1)
int(x^2-1,x,-1,1)
int(x*y,x)
int(x*y,y,0,x)
int(int(x*y,y,0,x),x,0,1)

Pour calculer une intégrale, un logiciel de calcul formel recherche une primitive puis l'évalue entre les bornes, afin d'obtenir une valeur exacte. Dans certains cas, il est inutile de calculer une primitive, soit parce qu'il n'en existe pas qui s'exprime avec les fonctions élémentaires, soit parce qu'un calcul numérique est plus adapté (par exemple si le temps de calcul de la primitive est trop long, si la fonction présente des singularités dans l'intervalle d'intégration, etc...). Dans ce cas, on demande une valeur approchée en utilisant evalf, ou bien on utilise directement la fonction romberg, qui est appelée par evalf.

int(exp(-x^2))
int(exp(-x^2),x,0,10)
evalf(int(exp(-x^2),x,0,10))
romberg(exp(-x^2),x,0,10)
ans()/sqrt(pi))

Intégrales
int(E)	primitive d'une expression
int(E,x,a,b)	intégrale exacte
romberg(E,x,a,b)	intégrale approchée

Résolution d'équations Comme pour les intégrales on distingue :

$\bullet$

la résolution exacte qui renvoie toutes les solutions lorsque c'est possible (par exemple pour certaines équations polynomiales ou s'y ramenant)

$\bullet$

la résolution approchée qui calcule par un algorithme itératif une valeur proche d'une des solutions.

La résolution exacte s'effectue à l'aide de solve, dont le premier argument est une équation. Le membre de droite est supposé nul s'il n'est pas précisé. Par défaut solve ne retourne pas les solutions complexes. Pour les obtenir, il faut activer l'option Complex à partir du bouton rouge sur fond gris cas (en bas à gauche). Exécutez les commandes suivantes avant et après avoir activé l'option Complex.

solve(x^2-a*x+2,x)
solve(x^2+2,x)
solve(x^3=1,x)

Les racines exactes sont calculées pour les polynômes de degré 1 et 2 (les formules de Cardan et Ferrari pour les degrés 3 et 4 ne sont pas utilisées, car les solutions obtenues ne sont pas facilement maniables). En degré supérieur, la fonction solve affiche un message d'erreur et renvoie une liste vide.

Pour les équations trigonométriques, les solutions principales sont renvoyées. Pour obtenir toutes les solutions, il faut activer l'option All_trig_sol. Comparer les commandes suivantes avec et sans cette option.

solve(cos(x),x)
solve(cos(x)+sin(x),x)

La fonction solve peut aussi résoudre des systèmes d'équations. Le premier argument est la liste des équations, le second est la liste des variables.

solve([x^2+y-2,x+y^2-2],[x,y])

La fonction de résolution approchée est fsolve. Elle propose en option différents algorithmes (menus Calc->Num_solve_eq et Calc->Num_solve_syst). Le plus célèbre est l'algorithme de Newton, qui a de multiples variantes. Le principe général de tous ces algorithmes est de calculer les termes successifs d'une suite qui converge vers une solution de l'équation ou du système proposé. Il faut pour cela choisir selon les cas un point de départ, ou un intervalle de recherche.

fsolve((x^5+2*x+1)=0,x,1,newton_solver)
newton(x^5+2*x+1,x,1.0)
newton(x^5+2*x+1,x,1+i)
newton(x^5+2*x+1,x,-1+i)

Équations
solve(eq,x)	résolution exacte d'une équation
solve([eq1,eq2],[x,y])	résolution exacte d'un système
fsolve(eq,x)	résolution approchée d'une équation
fsolve([eq1,eq2],[x,y])	résolution approchée d'un système
newton	méthode de Newton
linsolve	système linéaire
proot	racines approchées d'un polynôme

Équations différentielles Comme dans les deux sections précédentes, on distingue le calcul exact, qui n'est pas toujours possible, du calcul approché. La résolution exacte s'effectue par desolve. Les dérivées de la fonction inconnue $y$ peuvent s'écrire $y'$, $y''$, qui sont traduits en diff(y), diff(diff(y)). Si on ne spécifie pas de condition initiale, le résultat est donné en fonction de constantes arbitraires.

desolve(y'=y,y)
desolve(y''+2*y'+y=0,y)
desolve((x^2-1)*y'+2*y=0,y)

Les conditions initiales sont vues comme des équations supplémentaires, qui forment une liste avec l'équation différentielle.

desolve([y'=y,y(0)=1],y)
desolve([y"+2*y'+y=0,y(0)=1],y)
desolve([y"+2*y'+y=0,y(0)=1,y'(0)=1],y)
desolve([y"+2*y'+y=0,y(0)=1,y(1)=0],y)
desolve([(x^2-1)*y'+2*y=0,y(0)=1],y)
desolve((t^2-1)*diff(y(t),t)+2*y(t)=0,y(t))

La fonction odesolve permet de résoudre par des méthodes numériques une équation différentielle $y'=f(x,y)$ passant par un point $(x_0,y_0)$. Par exemple :

odesolve(sin(x*y),[x,y],[0,1],2)

permet de calculer $y(2)$ où $y(x)$ est la solution de $y'(x)=\sin(xy)$, telle que $y(0)=1$. La fonction plotode représente graphiquement la solution d'une équation différentielle, plotfield représente le champ des tangentes. La fonction interactive_plotode représente le champ des tangentes et permet de cliquer sur le graphique pour tracer les solutions passant par les points cliqués.

plotfield(sin(x*y),[x,y])
plotode(sin(x*y),[x,y],[0,1])
erase()
interactive_plotode(sin(x*y),[x,y])

Équations différentielles
desolve	résolution exacte
odesolve	résolution approchée
plotode	tracé de trajectoire
plotfield	tracé d'un champ de vecteurs
interactive_plotode	interface cliquable