Méthode de bissection

>

La méthode de bissection est une méthode assez élémentaire d'approximations successives d'un zéro réel d'une fonction. Cette méthode repose sur le théorème de la valeur intermédiaire. Le théorème de la valeur intermédiaire établit que si f est une fonction telle que

• 1) f est continue sur un intervalle [a,b]
• 2) f(a) et f(b) sont de signes contraires

alors il existe au moins un nombre réel r ]a,b[ tel que .

Sans perte de généralité, envisageons la situation où il ne se présente qu'un seul zéro réel r ]a,b[.

Pour les développements qui vont suivre, renommons l'intervalle [a,b] par [ ].

Le calcul du milieu, noté , de l'intervalle [ ] donne une première valeur approchée du zéro réel r de la fonction.

>

On dit aussi que est une approximation du zéro réel r. Dans le cas où le tracé de la fonction n'est pas une droite, on a que . La valeur réalise une première bissection de l'intervalle [ ]. Analysons ensuite le signe du produit :

• si , alors, en vertu du théorème de la valeur intermédiaire, il y a donc un zéro (réel) dans l'intervalle ] [
• sinon, c'est le produit qui doit être négatif et il y aurait donc un zéro (réel) dans l'intervalle ] [

Si le produit est nul, dans ce cas, et nous avons alors trouvé un zéro réel exact de la fonction f (une racine de l'équation). Mais, il faudrait être plutôt chanceux. Ne comptons pas trop sur cette chance.

On peut répéter ce processus chaque fois que le théorème de la valeur intermédiaire s'applique. Désignons par [ ] l'intervalle où le théorème de la valeur intermédiaire s'applique. En répétant la bissection de l'intervalle avec la valeur du milieu , on obtient une deuxième approximation d'un zéro de la fonction et . Et nous avons, bien sûr .

>

En répétant ce processus aussi longtemps que l'on veut, on crée une séquence d'approximations successives , , , … et une séquence de sous-intervalles successifs [ ], [ ], , …. où chaque sous-intervalle de la séquence contient le zéro réel de la fonction f et dont la largeur de chacun d'eux est égale à la moitié de la largeur du sous-intervalle précédent. Dans la pratique, nous appliquerons la bissection des différents sous-intervalles [ ] jusqu'à ce que le zéro réel à localiser soit à l'intérieur d'un n-ième sous-intervalle dont la demi largeur sera inférieure à une certaine valeur fixée au départ. On désignera par la lettre E cette valeur fixée au départ et on appellera cette valeur "erreur maximale tolérée". Ce procédé itératif sera donc interrompu à la n-ième itération lorsque = .

>

Algorithme de la méthode de bissection

Soit f une fonction continue sur un intervalle [ ] telle que l'on ait .

Soit E désignant la valeur maximale de l'erreur tolérée, c'est-à-dire E = .

Répéter les étapes 1 à 5 pour , 2, 3, …, n , jusqu'à ce que < E

1. Calculer

2. Calculer . Si , on arrête. Un zéro exact est trouvé.

3. Calculer

4. Si , alors posons et

5. Si > 0, alors posons et

La méthode de bissection fonctionne toujours, c'est-à-dire que . Avec la méthode de bissection, on est donc assuré de la convergence vers un zéro réel. Cette convergence n'est pas très rapide. À l'aide d'exemples, on le constatera en comparant le nombre d'itérations que mets chacune des trois méthodes avant d'atteindre la valeur maximale de l'erreur tolérée.

Comme premier exemple d'application de la méthode de bissection, considérons de nouveau la fonction f définie par . Appliquons l'algorithme de bissection avec la fonction f.

> f:=x->-x^2-x+2-cos(x):
plot([x,f(x),x=-4..3],color=orange,thickness=2,view=[-4..3,-6..2],xtickmarks=6);

>

Puisque la fonction f est continue sur R , elle est donc continue sur l'intervalle [-3,-2]. La fonction f est aussi continue sur l'intervalle [0,1]. Dans les deux cas, le théorème de la valeur intermédiaire s'applique. Obtenons d'abord une approximation du zéro réel localisé l'intervalle [-3,-2].

Pour transposer sur le plan informatique l'algorithme de bissection, il est nécessaire de prendre connaissance des instructions de programmation que sont:

• les boucles
• les tests

Présentons alors brièvement ces différentes structures de contrôles.

Les boucles sont utiles afin d'exécuter un bloc de requêtes que l'on désire répéter. On utilisera la boucle FOR si le nombre de répétitions du bloc de requêtes est connu sinon on utilisera la boucle WHILE .

La structure d'une boucle FOR est la suivante:

for indice from valeur_début to valeur_fin by incrément do

bloc de requêtes

od ;

Exemple: Soit l'impression des 5 premiers entiers impairs positifs.

> for k from 0 to 4 by 1 do
print(2*k+1);
od;

>

Le nombre de répétition était connu d'avance.

La structure d'une boucle WHILE est la suivante:

while condition vraie do
bloc de requêtes

od ;

Exemple: Soit la division par 4 du nombre 256. Poursuivons la division par 4 des quotients successifs aussi longtemps que chaque quotient successif demeure supérieur à 0,0001.

> quotient:=256/4;
while quotient > 0.0001 do
quotient:=evalf(quotient/4)
od;

>

Le nombre de répétition était inconnu d'avance.

Les tests sont utiles lorsqu'il faut, selon un contexte donné, exécuter conditionnellement un bloc de requêtes.

La structure de base d'un test if est la suivante:

if condition vraie then
bloc de requêtes

fi ;

On peut également exécuter conditionnellement un autre bloc de requêtes selon que la condition soit vraie ou fausse.

if condition vraie then
bloc de requêtes A

else

bloc de requêtes B

fi ;

Il est possible également d'utiliser plusieurs tests imbriqués.

if condition vraie then
bloc de requêtes A

elif condition vraie then

bloc de requêtes B

elif condition vraie then

bloc de requêtes C

...............

else

bloc de requêtes par défaut

fi ;

Exemple simplet.

> a:=-8;
b:=2;
if a=b then
print(`a et b sont égaux`)
elif a<b then
print(`a est inférieur à b`)
else
print(`a est supérieur à b`)
fi;

>

Vous pouvez expérimenter les tests imbriqués précédents en modifiant les valeurs de a et b et en exécutant à nouveau le bloc précédent.
Suggestion: Par exemple, sans changer la valeur de a , donnez à b la valeur ou même . Qu'est-ce qui se passe ? Comment pouvez-vous expliquer ce qui arrive ? Modifiez les requêtes qu'il faut pour que ça marche.

Revenons maintenant à notre exemple. On pourrait, bien sûr, appliquer étape par étape l'algorithme de bissection, mais, avec la connaissance de ces structures de contrôle, nous sommes maintenant en mesure d'automatiser cet algorithme avec un programme informatique. Un programme informatique est constitué d'un certain nombre de requêtes formant un bloc d'instructions permettant d'automatiser l'exécution de tâches plus ou moins complexes. La transposition de l'algorithme de bissection ne testera pas si le théorème de la valeur intermédiaire s'applique sur l'intervalle en cause. La programmation de l'algorithme supposera que les conditions de son applicabilité sont satisfaites.

Rappelons que . En effet,

> f:=x->-x^2-x+2-cos(x);
is(f(-3)*f(-2),negative);

>

Obtenons la séquence de valeurs , , , … avec E = 0,00001. Incluons, dans la transposition informatique de l'algorithme de bissection décrit plus haut, le calcul du nombre d'itérations que la boucle mets pour que < E .

Assignons d'abord les valeurs requises.

> a:=-3;
b:=-2;
E:=0.00001;
Itération:=0;

>

Exécutons ensuite le programme ci-dessous qui transpose sur le plan informatique l'algorithme de bissection.

> while evalf(abs(b-a)) > evalf(2*E) do
m:= (a+b)/2;
if is(f(m)*f(a),negative) then
b:=m
elif is(f(m)*f(a),positive) then
a:=m
else
print(`Le zéro trouvé est exact et vaut `,m);
return;
fi;
Itération:=Itération+1;
od:
m:=(a+b)/2:
Itération:=Itération+1:
print(`Le zéro réel approximatif est `,evalf(m));
print(`Cela a nécessité `,Itération,`itérations`);

>

Libérons les variables qui ont été utilisées dans le programme précédent.

> a:='a':b:='b':E:='E':Itération:='Itération':

On peut donc affirmer que le zéro cherché dans l'intervalle ]-3,-2[ est r » -2,17992 avec une erreur maximale égale à 0,00001.

Donc que r [2,17991; 2,17993].

Évaluons f(-2,179924011) pour voir.

> f(-2.179924011);

>

On pourrait exiger que f( r ) soit davantage près de 0. Il suffirait alors de prendre une marge d'erreur E plus petite pour le calcul de l'approximation du zéro r.

ATTENTION : Il faut, bien sûr, tenir compte de la valeur courante de la variable d'environnement Digits . Par exemple, en ne modifiant pas sa valeur par défaut (10 chiffres décimaux), il serait inapproprié de considérer, par exemple, une valeur , car l'affichage du résultat ne se fera, de toutes façons, qu'avec 10 chiffres décimaux.

Pour être en mesure d'utiliser de manière plus convivial ce programme dans d'autres situations, par exemple, avec une valeur E de la marge d'erreur différente ou avec un intervalle différent ou encore avec d'autres fonctions même, nous allons inclure les instructions composant le programme dans une procédure. Une procédure est en quelque sorte une macro-commande semblable à n'importe quelle autre macro-commande Maple.

La structure d'une procédure commence et se termine avec les mots clefs proc … end .

nom:= proc (arg_1, arg_2, …, arg_n)
global var_1, var_2, …, var_k;
local var_1, var_2, …, var_l;
corps de la procédure
end ;

Voici un exemple simple d'une procédure ayant trois arguments qui donnera comme résultat le maximum de trois nombres entiers donnés.

> Maximum:=proc(a,b,c)
local x;
if a>b then x:=a else x:=b fi;
if c>x then c else x fi
end;

>

Expérimentons cette procédure avec les entiers . Ces entiers seront assignés, dans l'ordre, aux arguments formels a, b et c de la procédure Maximum .

> Maximum(-12,-25,-6);

>

Une procédure peut donc permettre d'assigner un contenu à certaines variables du corps de la procédure par l'intermédiaire de ses arguments formels. Au moment d'écrire une procédure, le programmeur doit faire en sorte qu'elle doit tenir compte de toutes les situations qui empêcheraient le corps de la procédure de donner le résultat attendu. Par exemple, voyons comment la procédure Maximum retournera le maximum de trois nombres suivants: -1, 3 et .

> Maximum(-1,3,sqrt(2));

Error, (in Maximum) cannot evaluate boolean: -2^(1/2) < -3

>

La procédure a planté sur une instruction du corps de la procédure car une requête de celui-ci n'a pas pu être exécutée correctement. On est heureusement ici assez bien informé sur la cause du plantage. Ce n'est pas toujours le cas. Pour réaliser une bonne programmation, il est d'abord nécessaire de contrôler la nature du contenu qui sera assigné ultérieurement à des variables du programme. De cette façon, on gère soi-même les limites qu'on impose à la macro-commande. Il était prévu au départ que chaque nombre qui serait passé à chaque argument formel serait un nombre entier. Alors, à l'aide de l'opérateur de conformité de type :: , testons le type « integer » de chaque nombre qui seront passé à chacun des paramètres formels a, b et c.

> Maximum:=proc(a::integer,b::integer,c::integer)
local x;
if a>b then x:=a else x:=b fi;
if c>x then c else x fi
end;

>

Exécutons de nouveau la macro-commande Maximum ainsi modifiée.

> Maximum(-1,3,sqrt(2));

Error, invalid input: Maximum expects its 3rd argument, c, to be of type integer, but received 2^(1/2)

>

La procédure a encore planté mais, cette fois, c'était prévu.

Nous sommes maintenant en mesure d'intrégrer la transposition informatique de l'algorithme de bissection dans le corps d'une procédure. Nous allons donné le nom bissection à cette procédure. Dans l'élaboration de la procédure bissection, on testera, au départ, si le théorème de la valeur intermédiaire s'applique. En fait, si la fonction change effectivement de signe aux bornes de l'intervalle considéré. Si ce n'est pas le cas, on fera en sorte que le résultat de la macro-commande soit un message d'erreur signalant à l'utilisateur que cette condition d'applicabilité de l'algorithme de bissection n'est pas satisfaite.

> bissection:=proc(f::procedure,intervalle::anything=range,tolérance::anything=realcons)
local a,b,Bornes,E,Itération,m;
Bornes:=lhs(rhs(intervalle)), rhs(rhs(intervalle));
a:=min(Bornes);
b:=max(Bornes);
if not(evalf(f(a)*f(b))<0) then
ERROR(`La fonction ne change pas de signes aux bornes de l'intervalle considéré.`)
fi;
Itération:=0;
E:=abs(rhs(tolérance));
while evalf(abs(b-a)) > evalf(2*E) do
m:=(a+b)/2;
if evalf(f(m)*f(a)) < 0 then
b:=m
elif evalf(f(m)*f(a)) > 0 then
a:=m
else
print(`Le zéro réel trouvé est exact et vaut `,m);
return;
fi;
Itération:=Itération+1;
od:
m:= (a+b)/2;
Itération:=Itération+1;
print(`Le zéro réel approximatif est `,evalf(m));
print(`Cela a nécessité `, Itération,` itérations`)
end:

>

Première version de la macro-commande « bissection »

La macro-commande

bissection(f,intervalle,tolérance)

applique la méthode de bissection pour estimer un zéro réel d'une fonction réelle d'une variable réelle sur un intervalle donné.

Cette première version de la macro-commande bissection possède trois arguments:

• f : La fonction f doit être une procédure définie avec l'opérateur fonctionnel flèche " -> "
• intervalle : L'intervalle considéré doit être énoncé dans la forme x = a .. b
• tolérance : La précision de l'estimation doit être énoncée dans la forme E = valeur

Rappelons-nous le tracé de la fonction f.

> f:=x->-x^2-x+2-cos(x):
plot([x,f(x),x=-4..3],color=orange,thickness=2,view=[-4..3,-6..2],xtickmarks=6);

>

Utilisons la macro-commande bissection pour obtenir une approximation du zéro réel de la fonction f dans l'intervalle [-3,-2] avec une erreur maximale E = 0,00001.

> bissection(f,x=-3..-2,E=0.00001);

>

Obtenons maintenant une approximation de l'autre zéro compris dans l'intervalle [0,1] avec une erreur maximale E = 0,00000001.

> bissection(f,x=0..1,E=0.00000001);

>

On peut donc affirmer que le second zéro cherché est r = 0,72548992 avec une erreur maximale égale à 0,00000001.

Donc que r [0,72548991 , 0,72548993].

>

Sachant que f( x ) ne change pas de signes aux bornes de l'intervalle [-2,-1], testons si, dans ce cas, le résultat de la macro-commande bissection sur cet intervalle sera bien le messsage d'erreur qui a été prévu.

> bissection(f,x=-2..-1,E=0.00001);

Error, (in bissection) La fonction ne change pas de signes aux bornes de l'intervalle considéré.

>

Avant la présentation de la méthode d'interpolation linéaire, peaufinons la macro-commande bissection en ajoutant un quatrième argument formel qui autorisera ou non, selon le cas, l'impression d'un tableau informatif. Un tel tableau présentera le détail de certains calculs jusqu'à ce l'erreur maximale tolérée soit atteinte. De plus, dans cette seconde mouture de la procédure bissection , la variable d'environnement Digits sera localement initialisée à 40 afin de minimiser les cumuls d'erreurs dans les cas de calculs impliquant plusieurs opérations mathématiques. Compte tenu de ses capacités de mise en forme, c'est la macro-commande prinf plutôt que print qui sera utilisée. Finalement, la plus plus petite valeur de E qui sera acceptée par la procédure est . (On pourra modifiée cette valeur sans peine mais la présentation du tableau risque d'en souffrir. Je n'ai pas déployé d'efforts de programmation pour cette mise en forme qui pourrait prendre en charge la valeur de E , car cela n'est pas pertinent dans le contexte actuel).

> bissection:=proc(f::procedure,intervalle::anything=range,
tolérance::anything=realcons,tableau::name)
local a,b,Bornes,Détail,E,Itération,m;
if nargs<>4 then
ERROR(`Le nombre d'arguments requis est 4. Vous en avez donné `||nargs||`.`)
fi;
if rhs(tolérance)<0.1e-14 then
ERROR(`La valeur minimale E acceptée est 0.1e-14).`)
fi;
Digits:=40;
Bornes:=lhs(rhs(intervalle)), rhs(rhs(intervalle));
a:=min(Bornes);
b:=max(Bornes);
if not(evalf(f(a)*f(b))<0) then
ERROR(`La fonction ne change pas de signes aux bornes l'intervalle considéré.`)
fi;
Itération:=0;
E:=abs(rhs(tolérance));
Détail:=[];
while evalf(abs(b-a)) > evalf(2*E) do
m:=(a+b)/2;
Itération:=Itération+1;
Détail:=Détail,[Itération,evalf(abs(b-a)/2),evalf((a+b)/2),evalf(f((a+b)/2))];
if evalf(f(m)*f(a)) < 0 then
b:=m
elif evalf(f(m)*f(a)) > 0 then
a:=m
else
print(`Le zéro réel trouvé est exact et vaut `,m);
return;
fi;
od:
m:=(a+b)/2;
Itération:=Itération+1;
Détail:=Détail,[Itération,evalf(abs(b-a)/2),evalf((a+b)/2),evalf(f((a+b)/2))];
if tableau=non then
printf(`\n%s`,`Avec la méthode de bissection,`);
printf(`\n%s% .15g`,`le zéro réel approximatif obtenu est r = `,evalf(m));
printf(`\n%s%d%s% 0.15f`, `Cela a nécessité `, Itération,` itérations avec E = `,E)
else
printf(`\n%s% .15f`,`Méthode de bissection avec E = `,E);
printf(`\n%s%a`,`Intervalle initial `,intervalle);
printf(`\n| k | d[k] | m[k] | f(m[k]) | \n|=======|=====================|=======================|=======================| \n`);
seq(printf("|%5d | % 0.15f | % 0.15f | % 0.15f |\n", Détail[k,1],Détail[k,2],Détail[k,3],Détail[k,4]),k=2..Itération+1)
fi
end:

>

Version finale de la macro-commande « bissection »

La macro-commande

bissection(f,intervalle,tolérance,tableau)

applique la méthode de bissection pour estimer un zéro réel d'une fonction réelle d'une variable réelle sur un intervalle donné.

La version finale de la macro-commande bissection possède quatre arguments:

• f : La fonction f doit être une procédure définie avec l'opérateur fonctionnel flèche " -> "
• intervalle : L'intervalle considéré doit être énoncé dans la forme x = a .. b
• tolérance : La précision de l'estimation doit être énoncée dans la forme E = valeur
• tableau : Si la valeur de l'argument tableau est non , c'est seulement un résumé des résultats des calculs qui sera affiché.
  Sinon, ce sera les détails des différents calculs qui seront affichés.
  

Expérimentons la version finale de la macro-commande bissection avec les "valeurs" non et oui respectivement sur l'intervalle [-2,5 -1,5] avec E = 0,00001.

> bissection(f,x=-2.5..-1.5,E=0.00001,non);

Avec la méthode de bissection,

le zéro réel approximatif obtenu est r = -2.179924011230469

Cela a nécessité 17 itérations avec E =  .000010000000000

>

> bissection(f,x=-2.5..-1.5,E=0.00001,oui);

Méthode de bissection avec E =  .000010000000000

Intervalle initial x = -2.5 .. -1.5

|   k   |         d[k]        |          m[k]         |         f(m[k])       | 

|=======|=====================|=======================|=======================| 

|    1  |   .500000000000000  |  -2.000000000000000   |    .416146836547142   |

|    2  |   .250000000000000  |  -2.250000000000000   |   -.184326377277261   |

|    3  |   .125000000000000  |  -2.125000000000000   |    .135641334704305   |

|    4  |   .062500000000000  |  -2.187500000000000   |   -.019307050663167   |

|    5  |   .031250000000000  |  -2.156250000000000   |    .059413495824725   |

|    6  |   .015625000000000  |  -2.171875000000000   |    .020366396519555   |

|    7  |   .007812500000000  |  -2.179687500000000   |    .000608162776562   |

|    8  |   .003906250000000  |  -2.183593750000000   |   -.009329797051620   |

|    9  |   .001953125000000  |  -2.181640625000000   |   -.004355908463096   |

|   10  |   .000976562500000  |  -2.180664062500000   |   -.001872646056177   |

|   11  |   .000488281250000  |  -2.180175781250000   |   -.000631934990753   |

|   12  |   .000244140625000  |  -2.179931640625000   |   -.000011809450799   |

|   13  |   .000122070312500  |  -2.179809570312500   |    .000298195826210   |

|   14  |   .000061035156250  |  -2.179870605468750   |    .000143197978631   |

|   15  |   .000030517578125  |  -2.179901123046875   |    .000065695461659   |

|   16  |   .000015258789063  |  -2.179916381835938   |    .000026943304867   |

|   17  |   .000007629394531  |  -2.179924011230469   |    .000007567001894   |

>

Comme autre exemple, considérons de nouveau l'équation polynomiale du troisième degré du début.

> f:=x->x^3-5*x^2+8*x-3:
plot([x,f(x),x=-1..4],color=orange,view=[-1..4,-5..5]);

>

Obtenons le tableau des approximations successives à l'aide de la macro-commande bissection sur l'intervalle [0,1] et avec une valeur E = 0,000000000000001.

> bissection(f,x=0..1,E=0.1e-14,oui);

Méthode de bissection avec E =  .000000000000001

Intervalle initial x = 0 .. 1

|   k   |         d[k]        |          m[k]         |         f(m[k])       | 

|=======|=====================|=======================|=======================| 

|    1  |   .500000000000000  |   .500000000000000   |   -.125000000000000   |

|    2  |   .250000000000000  |   .750000000000000   |    .609375000000000   |

|    3  |   .125000000000000  |   .625000000000000   |    .291015625000000   |

|    4  |   .062500000000000  |   .562500000000000   |    .095947265625000   |

|    5  |   .031250000000000  |   .531250000000000   |   -.011199951171875   |

|    6  |   .015625000000000  |   .546875000000000   |    .043193817138672   |

|    7  |   .007812500000000  |   .539062500000000   |    .016203403472900   |

|    8  |   .003906250000000  |   .535156250000000   |    .002553522586823   |

|    9  |   .001953125000000  |   .533203125000000   |   -.004310242831707   |

|   10  |   .000976562500000  |   .534179687500000   |   -.000875120051205   |

|   11  |   .000488281250000  |   .534667968750000   |    .000840010936372   |

|   12  |   .000244140625000  |   .534423828125000   |   -.000017352096620   |

|   13  |   .000122070312500  |   .534545898437500   |    .000411380029618   |

|   14  |   .000061035156250  |   .534484863281250   |    .000197026619617   |

|   15  |   .000030517578125  |   .534454345703125   |    .000089840424863   |

|   16  |   .000015258789063  |   .534439086914063   |    .000036244954973   |

|   17  |   .000007629394531  |   .534431457519531   |    .000009446626891   |

|   18  |   .000003814697266  |   .534427642822266   |   -.000003952685436   |

|   19  |   .000001907348633  |   .534429550170898   |    .000002746983085   |

|   20  |   .000000953674316  |   .534428596496582   |   -.000000602848086   |

|   21  |   .000000476837158  |   .534429073333740   |    .000001072068272   |

|   22  |   .000000238418579  |   .534428834915161   |    .000000234610286   |

|   23  |   .000000119209290  |   .534428715705872   |   -.000000184118852   |

|   24  |   .000000059604645  |   .534428775310516   |    .000000025245729   |

|   25  |   .000000029802322  |   .534428745508194   |   -.000000079436558   |

|   26  |   .000000014901161  |   .534428760409355   |   -.000000027095414   |

|   27  |   .000000007450581  |   .534428767859936   |   -.000000000924842   |

|   28  |   .000000003725290  |   .534428771585226   |    .000000012160443   |

|   29  |   .000000001862645  |   .534428769722581   |    .000000005617801   |

|   30  |   .000000000931323  |   .534428768791258   |    .000000002346479   |

|   31  |   .000000000465661  |   .534428768325597   |    .000000000710818   |

|   32  |   .000000000232831  |   .534428768092766   |   -.000000000107012   |

|   33  |   .000000000116415  |   .534428768209182   |    .000000000301903   |

|   34  |   .000000000058208  |   .534428768150974   |    .000000000097446   |

|   35  |   .000000000029104  |   .534428768121870   |   -.000000000004783   |

|   36  |   .000000000014552  |   .534428768136422   |    .000000000046331   |

|   37  |   .000000000007276  |   .534428768129146   |    .000000000020774   |

|   38  |   .000000000003638  |   .534428768125508   |    .000000000007995   |

|   39  |   .000000000001819  |   .534428768123689   |    .000000000001606   |

|   40  |   .000000000000909  |   .534428768122780   |   -.000000000001589   |

|   41  |   .000000000000455  |   .534428768123234   |    .000000000000009   |

|   42  |   .000000000000227  |   .534428768123007   |   -.000000000000790   |

|   43  |   .000000000000114  |   .534428768123121   |   -.000000000000391   |

|   44  |   .000000000000057  |   .534428768123178   |   -.000000000000191   |

|   45  |   .000000000000028  |   .534428768123206   |   -.000000000000091   |

|   46  |   .000000000000014  |   .534428768123220   |   -.000000000000041   |

|   47  |   .000000000000007  |   .534428768123227   |   -.000000000000016   |

|   48  |   .000000000000004  |   .534428768123231   |   -.000000000000004   |

|   49  |   .000000000000002  |   .534428768123233   |    .000000000000003   |

|   50  |   .000000000000001  |   .534428768123232   |   -.000000000000001   |

>

Comparons le résultat de la résolution de l'équation avec celui que donne la macro-commande fsolve .

> bissection(f,x=0..1,E=0.1e-14,non);

Avec la méthode de bissection,

le zéro réel approximatif obtenu est r =  .534428768123232

Cela a nécessité 50 itérations avec E =  .000000000000001

> Digits:=15:
fsolve(f(x)=0,{x});
Digits:=10:

>