3  Outils pour l’Analyse

3.1  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);f1(x);

Il ne faut pas définir la fonction dérivée par f1(x):=diff(f(x)), car dans cette définition, x aurait 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 (car le membre de droite d’une affectation n’est jamais évalué), ce qui serait inefficace.
Il faut utiliser f1:=function_diff(f), ou 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.

3.2  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 du développement limité demandé est 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 dans lequel apparaît une fonction order_size qui est telle que pour tout a>0, x^aorder_size(x) tend vers 0 quand x tend vers 0. 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),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)

3.3  Primitives et intégrales

La fonction int calcule une primitive d’une expressionpar rapport à x ou par rapport à la variable donnée en argument. Si l’expression comporte plusieurs variables, il vaut 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))

3.4  Résolution d’équations

Comme pour les intégrales on distingue :

• la résolution exacte qui renvoie toutes les solutions lorsque c’est possible (par exemple pour certaines équations polynomiales ou s’y ramenant)
• 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 cocher Complexe dans la configuration du CAS (Cfg->Configuration de CAS ou sur la barre-bouton Config :exact...)
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)

3.5  Equations 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₀,y₀). 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_odeplot 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])