La fonction Solve[] est ici d'un grand secours. C'est elle qui permet de résoudre une équation, donnée en premier paramètre, en fonction de la variable passée en second paramètre. Étant donné que la résolution est symbolique, elle peut se faire pour n'importe quel symbole apparaissant dans l'équation.

In[1]:= Solve[a x^2 + b x + c == 0, x]
Out[1]: {{x -> (-b - Sqrt[b^2 - 4 a c])/(2 a)}, {x -> (-b + Sqrt[b^2 - 4 a c])/(2 a)}}

Il est évidemment possible de résoudre des équations avec moins de paramètres :

In[1]:= Solve[ x^2 + x + 1 == 0, x]
Out[1]:= {{x -> -(-1)^(1/3)}, {x -> (-1)^(2/3)}}

Comme annoncé, on peut résoudre cette première équation pour une autre variable que l'habituel x :

In[1]:= Solve[a x^2 + b x + c == 0, a]
Out[1]:= {{a -> (-c - b x)/x^2}}

En la variable a, l'équation quadratique devient une simple équation linéaire, d'où la solution.

Il est aussi possible de ne récupérer qu'une seule solution, par exemple la seconde :

In[1]:= Solve[a x^2 + b x + c == 0, x][[2]]
Out[1]: {x -> (-b + Sqrt[b^2 - 4 a c])/(2 a)}

Évidemment, cela n'est possible que pour des équations acceptant autant de solutions.

La fonction Solve[] est toujours appropriée. Elle peut aussi prendre un troisième argument, en plus de l'expression de l'équation et de la variable à considérer, qui est le domaine sur lequel il faut chercher des solutions.

In[1]:= Solve[x^2 + 1 == 0, x]
Out[1]:= {{x -> -I}, {x -> I}}
In[2]:= Solve[x^2 + 1 == 0, x, Reals]
Out[2]:= {}
In[3]:= Solve[x^2 + 1 == 0, x, Complexes]
Out[3]:= {{x -> -I}, {x -> I}}
In[4]:= Solve[2 x + 7 == 0, x, Integers]
Out[4]:= {}
In[5]:= Solve[2 x + 7 == 0, x, Reals]
Out[5]:= {{x -> -(7/2)}}

La fonction Solve[] est aussi d'un grand secours. Elle peut aussi résoudre des équations pour plusieurs variables, par exemple :

In[1]:= Solve[a x + b y == c && c x + d y == e, {x, y}]
Out[1]: {{x -> -((c d - b e)/(b c - a d)), y -> -((-c^2 + a e)/(b c - a d))}}

Il est aussi possible de résoudre des systèmes non linéaires :

In[1]:= Solve[a x + b y == c && c x^2 + d y == e, {x, y}]
Out[1]:= {{x -> (a d - Sqrt[-4 b c^2 d + a^2 d^2 + 4 b^2 c e])/(2 b c), 
  y -> (2 c - (a^2 d)/(b c) + (
    a Sqrt[-4 b c^2 d + a^2 d^2 + 4 b^2 c e])/(b c))/(2 b)}, {x -> (
   a d + Sqrt[-4 b c^2 d + a^2 d^2 + 4 b^2 c e])/(2 b c), 
  y -> (2 c - (a^2 d)/(b c) - (
    a Sqrt[-4 b c^2 d + a^2 d^2 + 4 b^2 c e])/(b c))/(2 b)}}

La sortie texte n'est pas forcément la plus lisible par un humain, voici donc le rendu sous forme d'image :

La fonction Solve[] sert pour toutes les résolutions d'équations algébriques (pas pour les équations différentielles ou aux différences), mais aussi pour les inéquations algébriques. On peut les utiliser pour réduire l'ensemble des solutions possibles à un problème. Par exemple :

In[1]:= Solve[x^2 == 1 , x]
Out[1]:= {{x -> -1}, {x -> 1}}
In[2]:= Solve[x^2 == 1 && x < 0, x]
Out[2]:= {{x -> -1}}

À plusieurs variables, cela peut aussi donner des résultats intéressants :

In[3]:= Solve[{x^2 - y^2 == x y , x > 0, x > y}, {x, y}]
Out[3]:= {{y -> ConditionalExpression[-(x/2) - 1/2 Sqrt[5] Sqrt[x^2], x > 0]}, {y -> ConditionalExpression[-(x/2) + 1/2 Sqrt[5] Sqrt[x^2], x > 0]}}

La fonction Solve[] n'est en réalité utile que lorsqu'il n'y a qu'une solution ou un ensemble de solutions, pas une infinité de solutions. Rentrent dans cette catégorie les inéquations. On utilise alors la fonction Reduce[], qui réduit une ou plusieurs expressions en aussi peu que possible.

In[1]:= Reduce[2 x + 7 < 0, x]
Out[1]:= x < -(7/2)
In[2]:= Reduce[{2 x + 7 < 0, x > -5}, x]
Out[2]:= -5 < x < -(7/2)
In[3]:= Reduce[{2 x + 7 < 0, x > -5, x < -8}, x]
Out[3]:= False

À plusieurs variables, cela peut aussi donner des résultats intéressants :

In[1]:= Reduce[{2 x y + 7 < 0, x > -5, y < -8}, {x, y}]
Out[1]:= (0 < x <= 7/16 && y < -(7/(2 x))) || (x > 7/16 && y < -8)

On peut aussi user de fonctions transcendantes :

In[1]:= Reduce[Sin[x] < 0 && 0 < x < 2 pi, {x}]
Out[1]:= C[1] \[Element] Integers && C[1] >= 1 && ((1/2 (-\[Pi] + 2 \[Pi] C[1]) < pi < \[Pi] C[1] && -\[Pi] + 2 \[Pi] C[1] < x < 2 pi) 
       || (pi >= \[Pi] C[1] && -\[Pi] + 2 \[Pi] C[1] < x < 2 \[Pi] C[1]))

La fonction DSolve[] se charge de la résolution symbolique des équations différentielles, autant en systèmes que simples. Elle prend trois paramètres : l'expression de la ou des équations, la fonction inconnue et la variable indépendante.

In[1]:= DSolve[y'[x] *y[x] == x, y[x], x]
Out[1]:= {y[x]->-sqrt(2) sqrt(x^2/2+C[1])}, {y[x]->sqrt(2) sqrt(x^2/2+C[1])}}
In[2]:= DSolve[y'[x]*y[x] == x && y'[x] z'[x] == x, {y[x], z[x]}, x]]
Out[2]:= {{y[x] -> -Sqrt[x^2 + 2 C[1]], z[x] -> -(1/2) x Sqrt[x^2 + 2 C[1]] + C[2] - C[1] Log[x + Sqrt[x^2 + 2 C[1]]]}, 
	      {y[x] -> Sqrt[x^2 + 2 C[1]], z[x] -> 1/2 x Sqrt[x^2 + 2 C[1]] + C[2] + C[1] Log[x + Sqrt[x^2 + 2 C[1]]]}}

On les appelle aussi équations de récurrence.

La fonction RSolve[] se charge de la résolution symbolique de telles équations. Elle prend trois paramètres : l'expression de la ou des équations, la fonction inconnue et la variable indépendante.

In[1]:= RSolve[a[n + 1] - 2 a[n] == 1, a[n], n]
Out[1]:= {{a[n] -> -1 + 2^n + 2^(-1 + n) C[1]}}

On peut aussi poser des conditions initiales au problème :

In[1]:= RSolve[{a[n + 1] - 2 a[n] == 1, a[0] == 0}, a[n], n]
Out[1]:= {{a[n] -> -1 + 2^n}}

Cette fois, il faut utiliser la fonction NSolve[], où N est un préfixe pour indiquer la résolution numérique. On peut résoudre de simples équations polynomiales, les solutions ne devant pas forcément être réelles :

In[1]:= NSolve[x^2 + 2 x + 1 == 0, x]
Out[1]:= {{x -> -1.}, {x -> -1.}}
In[2]:= NSolve[x^5 + 2 x^2 + 1 == 0, x]
Out[2]:= {{x -> -1.36396}, 
          {x -> -0.0527742 - 0.688147 I}, 
          {x -> -0.0527742 + 0.688147 I}, 
		  {x -> 0.734756 - 0.999652 I}, 
          {x -> 0.734756 + 0.999652 I}}

Mathematica faisant surtout du calcul symbolique, on pourrait essayer de mélanger les deux (on n'obtiendra pas exactement les mêmes résultats que pour une résolution purement symbolique, même si elles sont mathématiquement équivalentes) :

In[1]:= NSolve[a*x^2 + b*x + c == 0, x]
Out[1]:= {{x -> (0.5 (-1. b - 1. Sqrt[b^2 - 4. a c]))/a}, 
          {x -> (0.5 (-1. b + Sqrt[b^2 - 4. a c]))/a}}
In[2]:= NSolve[a*x^4 + b*x^3 + c*x^2 + d*x + e == 0, x]

Pour cette dernière commande, la sortie est suffisamment longue pour ne pas être recopiée ici.

On peut toujours demander à restreindre les solutions à un certain intervalle, à résoudre un système d'équations, etc. La syntaxe est la même que pour une résolution symbolique.

In[1]:= NSolve[{x^2 + Log[y] == 0, 2 x + 2 y == 0}, {x, y}, Reals]
Out[1]:= {{x -> -0.652919, y -> 0.652919}}

À cette fin, on utilise la fonction FindRoot[]. Elle sert tant pour des équations à une seule inconnue

In[1]:= FindRoot[x == Sin[x], {x, 5}]
Out[1]:= {x -> -2.72975*10^-8}

qu'à plusieurs

In[1]:= phi = 0.5; g = 9.81; e = 0.001; L = 1; q = 1; nu = 0.00001;
FindRoot[1/Sqrt[f] == -2 Log[10, e/(Rationalize@3.71*phi) + Rationalize@2.51/(R*Sqrt[f])] && U == q/(phi^2*Pi) && R == (U*L)/nu, {{f, 0.01}, {R, 12500}, {U, 5}}]
Out[1]:= {f -> 0.0247596, R -> 127324., U -> 1.27324}

À chaque fois, il faut préciser une première estimation de la valeur de chaque variable, afin de converger vers une solution intéressante. Par exemple, si on avait précisé une tout autre valeur pour la première équation, le résultat aurait pu être totalement différent :

In[1]:= FindRoot[x == Sin[x], {x, -5}]
Out[1]:= {x -> 2.72975*10^-8}

In[2]:= FindRoot[x == Sin[x], {x, 0}]
Out[2]:= {x -> 0.}

Cette fois, il faut utiliser la fonction NDSolve[]. Elle peut résoudre des équations différentielles dans un certain intervalle pour une certaine variable, le retour est une fonction interpolée. On va dans cet exemple utiliser la fonction retournée pour en afficher un graphique :

In[1]:= f = NDSolve[{y''[x] == y[x] Cos[x + y[x]], y[0] == 1, y'[0] == 0}, y, {x, 0, 1}]
Out[1]:= {{y -> InterpolatingFunction[{{0., 1.}}, <>]}}
In[2]:= Plot[Evaluate[y[x] /. f], {x, 0, 1}, PlotRange -> All]

Notez que l'on doit fournir autant de conditions initiales que nécessaire pour obtenir une et une seule solution (un problème de Cauchy, autrement dit), soit autant de conditions que l'ordre de l'équation. Sinon, la solution ne sera pas unique et la résolution numérique ne pourra pas se faire. Ce problème est inhérent à l'analyse numérique.

On peut ensuite aussi récupérer des valeurs précises, même en dehors de l'intervalle de résolution de l'équation. Une extrapolation sera alors effectuée, les résultats ne seront pas précis, Mathematica vous préviendra dans ce cas.

In[1]:= {y[0.5], y'[2.5]} /. f
Out[1]:= {{1.048, -0.783099}}

On peut aussi résoudre des systèmes d'équations différentielles ordinaires avec cette fonction ; à titre documentaire, sachez qu'il est toujours possible de transformer une équation différentielle d'ordre n en un système de n équations différentielles du premier ordre, ce qui simplifie grandement la résolution numérique.

La fonction NDSolve[] en est toujours capable.

In[1]:= NDSolve[{D[u[t, x], t] == D[u[t, x], x, x], u[0, x] == 0, u[t, 0] == Cos[t], u[t, 5] == Sin[t]}, u, {t, 0, 10}, {x, 0, 5}];
Plot3D[Evaluate[u[t, x] /. %], {t, 0, 10}, {x, 0, 5}, PlotRange -> All]