Résolution d’équations : solve resoudre

### 6.60.6 Résolution d’équations : `solve resoudre`

`solve` permet de résoudre une équation ou un système d’équations polynômiales.
`solve` a 1 ou 2 arguments qui sont une expression xpr en x ou une expression xpr d’une variable var et le nom de cette variable var.
`solve` resout xpr=0 l’inconnue étant x ou var Attention
La deuxième variable peut spécifier un intervalle par exemple x=a..b pour n’avoir que les solutions dans l’intervalle [a;b] mais dans ce cas les solutions seront numériques et `solve` est alors identique à `fsolve`, par exemple :
`solve(t```^```2-2,t=0..2)` ou `fsolve(t```^```2-2,t=0..2)` renvoie `[1.41421356237]` alors que `solve(t```^```2-2,t)` renvoie `[-(sqrt(2)),sqrt(2)]`.

- Résolution d’une équation
  `solve` a comme arguments une équation entre deux expressions (ou une expression et dans ce cas `=0` est sous-entendu), et le nom d’une variable (par défaut `x`).
  `solve` résout cette équation.
- Résolution d’un système d’équations polynômiales
  Soit `solve` a comme arguments deux vecteurs : le vecteur des équations polynômiales et le vecteur contenant le nom des variables.
  `solve` résout ce système d’équations polynômiales.

Attention
Par défaut, `solve` ne renvoie que les solutions réelles : pour avoir les solutions complexes il faut être en mode complexe c’est à dire avoir coché `Complexe` dans la configuration du cas.
De plus,

- pour les équations comportant un dénominateur, `solve` ne tient pas compte du dénominateur et renvoie les solutions du numérateur.
  Par exemple `solve(ln(abs(x-2))/ln(x))` renvoie `[1,3]` ou
  `solve((x```^```2-2x)/x)` renvoie `[0,2]`,
- pour les équations trigonométriques, `solve` ne renvoie que les solutions principales : pour avoir toutes les solutions il faut avoir coché `All_trig_sol` dans la configuration du cas.

Exemples :

- Résoudre x4−1=3 On tape :
  `solve(x```^```4-1=3)`
  On obtient en mode réel :
  `[sqrt(2),-(sqrt(2))]`
  On obtient en mode complexe :
  `[sqrt(2),-(sqrt(2)),(i)*sqrt(2),-((i)*sqrt(2))]`
- Résoudre exp(x)=2
  On tape :
  `solve(exp(x)=2)`
  On obtient en mode réel :
  `[log(2)]`
- Résoudre en x,y le système x+y=1,x−y=0:
  On tape :
  `solve([x+y=1,x-y],[x,y])`
  On obtient :
  `[[1/2,1/2]]`
- Résoudre en x,y le système x2+y=2,x+y2=2
  On tape :
  `solve([x```^```2+y=2,x+y```^```2=2],[x,y])`
  On obtient :
  `[[-2,-2],[1,1],[(-sqrt(5)+1)/2,(1+sqrt(5))/2],`
  `[(sqrt(5)+1)/2,(1-sqrt(5))/2]]`
- Résoudre en x,y,z le système x2−y2=0,x2−z2=0:
  On tape :
  `solve([x```^```2-y```^```2=0,x```^```2-z```^```2=0],[x,y,z])`
  On obtient :
  `[[x,x,x],[x,-x,-x],[x,-x,x],[x,x,-x]]`
- Résoudre cos(2*x)=1/2
  On tape :
  `solve(cos(2*x)=1/2)`
  On obtient :
  `[pi/6,(-pi)/6]`
  On obtient en ayant coché `All_trig_sol` :
  `[(6*pi*n_0+pi)/6,(6*pi*n_0-pi)/6]`

Remarque Pour pouvoir par exemple trouver l’intersection d’une droite (donnée par son équation paramétrique) et un plan on peut mettre les équations sous la forme d’une liste contenant une liste.
Exemple : Trouver l’intersection de la droite D d’équation paramétrique [y−z=0,z−x=0,x−y=0] et du plan P d’équation x−1+y+z=0.
On tape

`solve([[y-z=0,z-x=0,x-y=0],x-1+y+z=0],[x,y,z])`

On obtient :

`[[1/3,1/3,1/3]]`

Remarque
Différence entre `solve` et `csolve` : En mode complexe `solve` renvoie le même résultat que `csolve` (pour `csolve` que l’on soit en mode complexe ou réel cela importe peu). Ainsi, si on ne veut pas que le résultat dépende du mode, pour avoir les solutions complexes il est préférable d’utiliser `csolve`.
On tape en mode réel :

`solve(re(r*exp(-(i)*t))-1,r)`

On obtient :

`[1/(cos(t))]`

car en mode réel l’inconnue `r` est considérée comme un nombre réel.
On tape en mode complexe :

`solve(re(r*exp(-(i)*t))-1,r)`

On obtient :

`[‘ x‘+(i)*1/(sin(t))*(-‘ x‘*cos(t)+1)]`

car en mode complexe, l’expression contient `i` donc l’inconnue `r` est considérée comme un nombre complexe. La solution complexe est :
`‘ x‘+(i)*1/(sin(t))*(-‘ x‘*cos(t)+1)` (la partie réelle de `r` vaut `‘ x‘` qui est un nombre rèel quelconque et la partie imaginaire de `r` est fonction de `‘ x‘`).
On tape en mode complexe ou réel:

`csolve(re(r*exp(-(i)*t))-1,r)`

On obtient :

`[‘ x‘+(i)*1/(sin(t))*(-‘ x‘*cos(t)+1)]`

car avec `csolve`, l’inconnue `r` est toujours considérée comme un nombre complexe.