Méthode de Newton-Raphson

>

Les méthodes de bissection et d'interpolation linéaire propose chacune une manière respective d'obtenir, étape par étape, une valeur approchée d'un zéro réel à localiser. La méthode de Newton-Raphson propose aussi, sous certaines conditions, une manière très différente d'obtenir, étape par étape, une valeur approchée d'un zéro réel.

La méthode de Newton-Raphson est basée sur l'utilisation de la tangente en un point de la courbe d'une fonction f. Plus précisément, le choix d'une première valeur approchée d'un zéro réel à localiser détermine un premier point ( ) sur la courbe qui sera considéré comme un premier point de tangence. Ce nombre est appelé « amorce » du procédé itératif de Newton-Raphson. L'abscisse du point d'intersection de la première tangente avec l'axe des x sera considéré comme une deuxième valeur approchée du zéro à localiser. À son tour, cette valeur permettra de considérer un deuxième point de tangence ( ). À nouveau, l'abscisse du point d'intersection de la deuxième tangente avec l'axe des x sera considéré comme une troisième valeur approchée du zéro. En poursuivant ce procédé itérativement, on obtiendra, sous certaines conditions, une séquence de différentes valeurs , , , , … qui vont se rapprocher de plus en plus d'un zéro réel de la fonction f.

>

Sélectionner le graphique ci-dessous afin d'activer la barre de menu contextuelle dédiée aux animations. Puis cliquer sur le bouton de départ pour lancer l'animation. Cette animation illustrera dynamiquement le procédé itératif de Newton-Raphson.

>

Si la séquence , , , …converge, elle converge vers un zéro réel de la fonction. Le graphique précédent ou son animation montre une situation où effectivement = r. Dans une telle situation, pour déterminer successivement les abscisses , , , … des points d'intersection des différentes tangentes avec l'axe des x , nous avons besoin de connaître l'équation de chaque tangente.

Rappelons que l'équation d'une droite passant par un point (a,b) de pente m est donnée par

Si la fonction f est une fonction dérivable au point ( ), la pente de la tangente à la courbe passant par ce point est directement donnée par . Alors, l'équation de chaque tangente à la courbe d'équation passant par le point ( ) est donnée par

y = ( ) +

y = ( ) +

L'abscisse du point d'intersection de la k-ième tangente avec l'axe des x est évidemment la racine de l'équation 0 = ( ) + . En résolvant, pour x, cette équation, on obtient

Or, la valeur de x est précisément la prochaine approximation qui est pris en charge dans ce procédé itératif. On déduit donc que

Cette équation est appelée équation de récurrence de Newton-Raphson. Cette manière de procéder à l'établissement des valeurs , , , …est appelée méthode de Newton-Raphson. Raphson a publié cette méthode en 1690, soit presque 50 ans avant que Newton lui-même ne l'ait publiée. Bien que Newton l'ait développée en 1671, il ne l'a, quant à lui, publiée qu'en 1736. Voilà pourquoi cette méthode porte les deux noms.

Appliquons cette formule de récurrence à la résolution de l'équation .

> Courbe_1:=plot([x,sin(x),x=-Pi..2*Pi],color=orange):
Courbe_2:=plot([x,exp(-x),x=-1..2*Pi],color=navy):
display([Courbe_1,Courbe_2],xtickmarks=6);

>

Puisque les fonctions et sont continues sur tous les réels R , il est graphiquement évident que l'équation possède une infinité de racines et donc que la fonction f définie par possède une infinité de zéros. Obtenons le tracé de la fonction f sur l'intervalle .

> f:=x->sin(x)-exp(-x):
plot([x,f(x),x=-1..4*Pi],color=orange,xtickmarks=10);

>

Estimons le zéro de la fonction f dans l'intervalle [0,1]. Afin d'appliquer la formule de Newton-Raphson plus efficacement, créons une fonction "newton" définie par

De cette manière, il appert que .

> newton:=x->evalf( x - f(x)/D(f)(x) );

>

Nous avons imbriqué le calcul dans la macro-commande evalf afin que l'image soit un nombre décimal.

Choisissons maintenant l'amorce et appliquons successivement la fonction newton à chaque résultat.

> x[0]:=1;

> x[1]:=newton(x[0]);

> x[2]:=newton(x[1]);

> x[3]:=newton(x[2]);

> x[4]:=newton(x[3]);

> x[5]:=newton(x[4]);

> x[6]:=newton(x[5]);

On remarque que les nombres et ne diffèrent qu'à partir de la décimale. Cela nous montre qu'effectivement les différentes valeurs convergent vers un nombre particulier compris dans l'intervalle [0,1]. Et nous en connaissons donc exactement les huit premières décimales de ce nombre.

Au lieu d'exécuter ces dernières requêtes manuellement, automatisons l'exécution de ces requêtes en les incluant dans une boucle FOR .

> n:=5;
x[0]:=1;
for k from 0 to n do
x[k+1]:=newton(x[k])
od;
n:='n':

>

Montrons que le nombre = 0,5885327439 est une bonne approximation de ce zéro en évaluant f( ).

> 'f'(x[4])=f(x[4]);

>

Hum! pas si mal... Pour obtenir une meilleur approximation de ce zéro (meilleur dans le sens que soit davantage près de zéro), il suffit d'augmenter la valeur de la variable d'environnement Digits et d'augmenter probablement le nombres d'itérations. En initialisant la variable d'environnement Digits avec une valeur plus grande que 10 et en augmentant le nombre d'itérations, nous allons, au fil des approximations successives, établir un plus grand nombre de chiffres exactes du zéro réel de la fonction f.

> Digits:=40:
n:=7:

> for k from 0 to n do
x[k+1]:=newton(x[k])
od;
n:='n':

>

Lorsque la variable Digits est initialisé à 40, les nombres et ne diffèrent qu'à partir de la décimale, on a donc obtenu 39 chiffres décimaux exacts du zéro de la fonction f..

> 'f'(x[6])=f(x[6]);

>

Redonnons à la variable Digits sa valeur par défaut.

> Digits:=10;

>

Avec l'équation de récurrence de Newton-Raphson formulée dans une boucle FOR , nous sommes en mesure de créer une procédure Maple permettant d'obtenir, de proche en proche, des approximations d'un zéro réel à localiser. Nous appellerons cette procédure newton .

La programmation d'un procédé itératif exige la présence d'un mécanisme d'arrêt des calculs, sinon, les calculs se poursuivraient indéfiniment. Avec les macro-commandes bissection et sécante , il a suffit de contrôler le nombre d'itérations avec le calcul successif de la demi-largeur de chaque intervalle [ ] encadrant le zéro réel à localiser. En effet, avec une valeur E donnée, l'inégalité = < E est nécessairement vérifiée après un nombre fini d'étapes.

Avec la méthode de Newton-Raphson, par contre, le contrôle du nombre d'itérations ne peut être fait à l'aide d'un tel calcul car cette méthode ne génère pas une séquence de tels intervalles. Ce contrôle passera alors tout simplement par le calcul de l'écart entre deux approximations successives. Le procédé itératif sera donc interrompu, après n étapes, lorsque < E , à condition qu'il y ait, bien sûr, convergence de la séquence des approximations successives.

Algorithme de la méthode de Newton-Raphson

Soit f une fonction dérivable.
Soit une première approximation d'un zéro de la fonction f.

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

Répéter l'étape ci-dessous pour k = 0, 1, 2, …, n, jusqu'à ce que < E

1.

> newton:=proc(f::procedure,essai::anything=realcons,
tolérance::anything=realcons,tableau::name)
local ancien,nouveau,Df,Détail,E,écart,Itération;
if rhs(tolérance)<0.1e-14 then
ERROR(`La valeur minimale E acceptée est 0.1e-14).`)
fi;
Digits:=40;
nouveau:=rhs(essai);
Itération:=0;
Détail:=[];
Détail:=Détail,[Itération,0,nouveau,evalf(f(nouveau))];
E:=abs(rhs(tolérance));
écart:=2*E;
while evalf(E) < abs(écart) do
ancien:=nouveau;
nouveau:=evalf(ancien-f(ancien)/D(f)(nouveau));
Itération:=Itération+1;
écart:=ancien-nouveau;
Détail:=Détail,[Itération,écart,nouveau,evalf(f(nouveau))];
od;
if tableau=non then
printf(`\n%s`,`Avec la méthode de Newton-Raphson,`);
printf(`\n%s% 0.13f%s`,`la valeur initiale donnée x[0] =`,rhs(essai),` a permis de trouver`),
printf(`\n%s%0.15f%s%0.15f`,`le zéro réel approximatif r =`,evalf(nouveau), ` avec E = `,E);
printf(`\n%s%d%s`,`Cela a nécessité `, Itération,` itérations`)
else
printf(`\n%s`,`Méthode de Newton-Raphson`);
printf(`\n%s %0.13f`,`La valeur initiale donnée est x[0] =`,rhs(essai)),
printf(`\n| k | x[k+1]-x[k] | x[k] | f(x[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=3..Itération+2)
fi
end:

>

ATTENTION: En donnant le nom " newton " à cette procédure et en l'exécutant, la fonction " newton " définie précédemment n'existe plus.

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

La macro-commande

newton(f,amorce,tolérance,tableau)

applique la méthode de Newton-Raphson pour estimer les zéros réels d'une fonction réelle d'une variable réelle.

La première version de la macro-commande newton possède quatre arguments:

• f : La fonction f doit être une procédure définie avec l'opérateur fonctionnel flèche " -> "
• amorce : La valeur d'amorce doit être énoncée dans la forme amorce = valeur
• 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.

Appliquons la macro-commande newton pour trouver la ou les racines de l'équation .

> Courbe_1:=plot([x,cos(x),x=-Pi..Pi],color=navy,legend="y = cos(x)"):
Courbe_2:=plot([x,x,x=-2..2],color=orange,legend="y = x"):
plots[display]([Courbe_1,Courbe_2],scaling=constrained);

>

L'équation à résoudre ne possède qu'une seule racine ( et sont continues sur [0,1]). Utilisons la macro-commande newton et considérons l'amorce = 0,5 avec une tolérance E = 0,0001.

> f:=x->x-cos(x):
newton(f,amorce=0.5,E=0.0001,non);

Avec la méthode de Newton-Raphson,

la valeur initiale donnée x[0] = .5000000000000 a permis de trouver

le zéro réel approximatif r =.739085133920807 avec E = .000100000000000

Cela a nécessité 3 itérations

Affichons le détail des calculs.

> newton(f,amorce=0.5,E=0.0001,oui);

Méthode de Newton-Raphson

La valeur initiale donnée est x[0] = .5000000000000

|   k   |      x[k+1]-x[k]    |          x[k]         |         f(x[k])       | 

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

|    1  |  -.255222417105636  |   .755222417105636   |    .027103311857467   |

|    2  |   .016080750955757  |   .739141666149879   |    .000094615380618   |

|    3  |   .000056532229072  |   .739085133920807   |    .000000001180978   |

>

La méthode de Newton-Raphson ne garantie aucunement que l'on va, justement, obtenir une séquence de valeurs , , , , …qui vont s'approcher aussi près que l'on voudra (selon la valeur E choisie) du zéro à localiser. Il n'y a pas de garantie de convergence. Il est possible qu'au cours du procédé itératif de Newton-Raphson, survient un point de tangence ( ) où la tangente est horizontale. Dans cette éventualité, le procédé itératif sera évidemment mis en échec car, dans ce cas, et donc, impossible de calculer . Il est donc nécessaire de tenir compte de cette éventualité dans la procédure newton .

Ce n'est pas seulement la possibilité d'une tangente horizontale qui peut mettre en échec la méthode de Newton-Raphson. Il y a aussi l'éventualité que la séquence de valeurs , , , , … ne converge pas vers un zéro réel de la fonction. Le graphique ci-dessous illustre une telle situation de divergence: dans cet exemple, le choix de l'amorce amène une divergence vers l'infini.

>

Cliquer sur le graphique ci-dessous pour activer la barre de menu contextuelle dédiée aux animations puis cliquer sur le bouton de départ pour lancer l'animation qui illustrera dynamiquement cette divergence vers l'infini.

>

L'animation précédente illustre clairement que la séquence de valeurs , , , , … ne converge pas vers un zéro réel de la fonction:

.

Il est même possible aussi que la séquence de valeurs , , , , … ne converge pas vers le zéro de la fonction sans pour autant qu'elle diverge vers l'infni ou vers moins l'infini. La séquence , , , , … pourrait cycler .

Avant de présenter une telle situation de divergence, peaufinons la macro-commande newton afin que le corps de la procédure puisse prévoir ces éventualités. Dans le mécanisme d'arrêt du procédé itératif, il ne faut donc pas uniquement se baser sur le calcul de l'écart entre deux approximations successives. Il faut prévoir la possibilité de la division par 0 ( ) et, en plus, limiter le nombre d'itération dans le cas où la séquences de valeurs , , , , … ne convergerait pas vers un zéro réel de la fonction.

> newton:=proc(f::procedure,essai::anything=realcons,maxiter::anything=posint,
tolérance::anything=realcons,tableau::name)
local ancien,nouveau,Df,Détail,E,écart,Itération,k;
if nargs<>5 then
ERROR(`Le nombre d'arguments requis est 5. 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;
Itération:=0;
Détail:=[];
nouveau:=evalf(rhs(essai));
Détail:=Détail,[Itération,0,nouveau,evalf(f(nouveau))];
E:=abs(rhs(tolérance));
écart:=E;
for k to rhs(maxiter) while evalf(E) <= abs(écart) do
ancien:=evalf(nouveau);
if evalf(f(nouveau))=0 then
printf(`\n%s%g`,`Le zéro réel trouvé est exact et vaut `,nouveau);
return
fi;
if evalf(D(f)(nouveau))=0 then
printf(`\n%s%d%s`,`La méthode de Newton-Raphson a échoué à la `,Itération,`ième itération(s).`);
return
fi;
nouveau:=evalf(ancien-f(ancien)/D(f)(nouveau));
Itération:=Itération+1;
écart:=ancien-nouveau;
Détail:=Détail,[Itération,écart,nouveau,evalf(f(nouveau))];
od;
if abs(écart) < E and tableau=non then
printf(`\nLa méthode de Newton-Raphson converge.`);
printf(`\n%s% 0.13f%s`,`La valeur initiale x[0] =`, rhs(essai) ,` a permis de trouver`),
printf(`\n%s% 0.15f%s% 0.15f`,`le zéro réel approximatif r =`,evalf(nouveau),` avec E = `,E);
printf(`\n%s%d%s`, `Cela a nécessité `, Itération,` itérations.`)
elif abs(écart) < E and tableau=oui then
printf(`\n%s`,`Méthode de Newton-Raphson`);
printf(`\n%s % 0.13f`,`La valeur initiale donnée est x[0] =`,rhs(essai)),
printf(`\n| k | x[k+1]-x[k] | x[k] | f(x[k]) | \n|=======|=======================|=======================|==========================| \n`);
seq(printf("|%5d | % 0.15f | % 0.15f | % 0.15E |\n",
Détail[k,1],Détail[k,2],Détail[k,3],Détail[k,4]),k=3..Itération+2);
printf(`\nLa méthode de Newton-Raphson converge.`);
printf(`\n%s% 0.15f%s% 0.15f`,`Le zéro réel approximatif est r =`,nouveau,` avec E = `,E);
elif tableau=non then
printf(`\n%s`,`La méthode de Newton-Raphson semble avoir échoué.`);
printf(`\n\n%s%d%s`, `Après `,Itération, ` itération(s), les approximations successives `);
printf(`\n%s`,`semblent diverger, soit par oscillation ou soit vers ± l'infini.`);
printf(`\n\n%s`,`Consulter le tableau des calculs pour déterminer s'il est pertinent`): printf(`\n%s`,`d'essayer une autre valeur d'amorce plus près du zéro réel à`):
printf(`\n%s`,`localiser et/ou d'augmenter le nombre d'itérations.`);
else
printf(`\n%s`,`La méthode de Newton-Raphson semble avoir échoué.`);
printf(`\n| k | x[k+1]-x[k] | x[k] | f(x[k]) | \n|=======|=======================|=======================|============================| \n`);
seq(printf("|%5d | % 0.15f | % 0.15f | % 0.15E |\n",
Détail[k,1],Détail[k,2],Détail[k,3],Détail[k,4]),k=3..Itération+2);
printf(`\n%s%d%s`, `Après `,Itération, ` itération(s), les approximations successives`);
printf(`\n%s`,`semblent diverger, soit par oscillation ou soit vers ± l'infini.`);
printf(`\n\n%s`,`Essayer, s'il y a lieu, une autre valeur d'amorce plus près `):
printf(`\n%s`,`du zéro réel à localiser et/ou augmenter le nombre d'itérations.`);
fi
end:

>

Version finale de la macro-commande « newton »

La macro-commande

newton(f,amorce,maxiter,tolérance,tableau)

applique la méthode de Newton-Raphson pour estimer les zéros réels d'une fonction réelle d'une variable réelle.

La version finale de la macro-commande newton possède cinq arguments:

• f : La fonction f doit être une procédure définie avec l'opérateur fonctionnel flèche " -> "
• amorce : La valeur d'amorce doit être énoncée dans la forme amorce = valeur
• maxiter : Le nombre maximum d'itérations doit être donné dans la forme n = nombre
• 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.

Soit la fonction f définie par . La méthode de Newton-Raphson appliquée à la fonction f est mise en échec et ce, quelque soit la valeur d'amorce : la séquence d'approximations successives diverge par oscillation.

> f:=x->piecewise(x<2,-sqrt(2-x),x>=2,sqrt(x-2));
plot([x,f(x),x=-2..5],thickness=2,color=orange,numpoints=80,view=[-2..5,-3..3]);

>

> newton(f,amorce=0.5,n=10,E=0.00001,non);

La méthode de Newton-Raphson semble avoir échoué.

Après 10 itération(s), les approximations successives 

semblent diverger, soit par oscillation ou soit vers ± l'infini.

Consulter le tableau des calculs pour déterminer s'il est pertinent

d'essayer une autre valeur d'amorce plus près du zéro réel à

localiser et/ou d'augmenter le nombre d'itérations.

>

Consultons le tableau des calculs.

> newton(f,amorce=0.5,n=10,E=0.00001,oui);

La méthode de Newton-Raphson semble avoir échoué.

|   k   |       x[k+1]-x[k]     |          x[k]         |            f(x[k])         | 

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

|    1  |  -3.000000000000000   |   3.500000000000000  |     1.224744871391589E+00   |

|    2  |   3.000000000000000   |   .500000000000000  |    -1.224744871391589E+00   |

|    3  |  -3.000000000000000   |   3.500000000000000  |     1.224744871391589E+00   |

|    4  |   3.000000000000000   |   .500000000000000  |    -1.224744871391589E+00   |

|    5  |  -3.000000000000000   |   3.500000000000000  |     1.224744871391589E+00   |

|    6  |   3.000000000000000   |   .500000000000000  |    -1.224744871391589E+00   |

|    7  |  -3.000000000000000   |   3.500000000000000  |     1.224744871391589E+00   |

|    8  |   3.000000000000000   |   .500000000000000  |    -1.224744871391589E+00   |

|    9  |  -3.000000000000000   |   3.500000000000000  |     1.224744871391589E+00   |

|   10  |   3.000000000000000   |   .500000000000000  |    -1.224744871391589E+00   |

Après 10 itération(s), les approximations successives

semblent diverger, soit par oscillation ou soit vers ± l'infini.

Essayer, s'il y a lieu, une autre valeur d'amorce plus près 

du zéro réel à localiser et/ou augmenter le nombre d'itérations.

>

Dans ce cas-ci, même si on augmentait le nombre d'térations, la méthode de Newton-Raphson serait encore mise en échec.

Cliquer sur le graphique ci-dessous pour activer la barre de menu contextuelle dédiée aux animations puis cliquer sur le bouton de départ pour lancer l'animation. On constatera qu'effectivement la méthode de Newton-Raphson diverge par oscillation. La valeur d'amorce utilisée a été = 0,5.

>

Le prochain exemple va montrer la "sensiblité" du procédé itératif de Newton-Raphson face au choix de la valeur d'amorce . On verra qu'en choisissant = 0,52, la méthode de Newton-Raphson est mise en échec tandis qu'avec le choix de = 0,48, la méthode converge.

> f:=x->x*exp(-x^2);
plot([x,f(x),x=-2..2],color=orange,thickness=2);

>

Soit la valeur d'amorce proposée.

> newton(f,amorce=0.52,n=20,E=0.00001,non);

La méthode de Newton-Raphson semble avoir échoué.

Après 20 itération(s), les approximations successives 

semblent diverger, soit par oscillation ou soit vers ± l'infini.

Consulter le tableau des calculs pour déterminer s'il est pertinent

d'essayer une autre valeur d'amorce plus près du zéro réel à

localiser et/ou d'augmenter le nombre d'itérations.

>

Consultons le tableau des calculs.

> newton(f,amorce=0.52,n=20,E=0.00001,oui);

La méthode de Newton-Raphson semble avoir échoué.

|   k   |       x[k+1]-x[k]     |          x[k]         |            f(x[k])         | 

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

|    1  |   1.132404181184669   |  -.612404181184669  |    -4.208824633100418E-01   |

|    2  |  -2.450378912795456   |   1.837974731610787  |     6.269416875604370E-02   |

|    3  |  -.319297816338598   |   2.157272547949385  |     2.054823701772557E-02   |

|    4  |  -.259673027614070   |   2.416945575563455  |     7.019092582029569E-03   |

|    5  |  -.226236881234015   |   2.643182456797470  |     2.443241023609862E-03   |

|    6  |  -.203747606965644   |   2.846930063763114  |     8.598354322710446E-04   |

|    7  |  -.187174623622555   |   3.034104687385669  |     3.047938629773795E-04   |

|    8  |  -.174257835896659   |   3.208362523282328  |     1.086010598643007E-04   |

|    9  |  -.163799102107172   |   3.372161625389500  |     3.884543244100688E-05   |

|   10  |  -.155092198941101   |   3.527253824330601  |     1.393649071379328E-05   |

|   11  |  -.147688651019029   |   3.674942475349630  |     5.012054146821964E-06   |

|   12  |  -.141287402519622   |   3.816229877869252  |     1.806087799977042E-06   |

|   13  |  -.135677459322946   |   3.951907337192198  |     6.519009073192055E-07   |

|   14  |  -.130705758877762   |   4.082613096069960  |     2.356325011638208E-07   |

|   15  |  -.126258082420783   |   4.208871178490743  |     8.527349871516074E-08   |

|   16  |  -.122247162596666   |   4.331118341087409  |     3.089225602745633E-08   |

|   17  |  -.118604976339413   |   4.449723317426822  |     1.120175154119473E-08   |

|   18  |  -.115277581558855   |   4.565000898985678  |     4.065152835424214E-09   |

|   19  |  -.112221558511077   |   4.677222457496755  |     1.476331599406062E-09   |

|   20  |  -.109401496221224   |   4.786623953717979  |     5.365059182420669E-10   |

Après 20 itération(s), les approximations successives

semblent diverger, soit par oscillation ou soit vers ± l'infini.

Essayer, s'il y a lieu, une autre valeur d'amorce plus près 

du zéro réel à localiser et/ou augmenter le nombre d'itérations.

>

Le tableau semble révéler que le choix de = 0,52 amène une séquence de valeurs divergentes bien qu'il semble que . Augmentons le nombre d'itérations "pour voir".

> newton(f,amorce=0.52,n=60,E=0.00001,oui);

La méthode de Newton-Raphson semble avoir échoué.

|   k   |       x[k+1]-x[k]     |          x[k]         |            f(x[k])         | 

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

|    1  |   1.132404181184669   |  -.612404181184669  |    -4.208824633100418E-01   |

|    2  |  -2.450378912795456   |   1.837974731610787  |     6.269416875604370E-02   |

|    3  |  -.319297816338598   |   2.157272547949385  |     2.054823701772557E-02   |

|    4  |  -.259673027614070   |   2.416945575563455  |     7.019092582029569E-03   |

|    5  |  -.226236881234015   |   2.643182456797470  |     2.443241023609862E-03   |

|    6  |  -.203747606965644   |   2.846930063763114  |     8.598354322710446E-04   |

|    7  |  -.187174623622555   |   3.034104687385669  |     3.047938629773795E-04   |

|    8  |  -.174257835896659   |   3.208362523282328  |     1.086010598643007E-04   |

|    9  |  -.163799102107172   |   3.372161625389500  |     3.884543244100688E-05   |

|   10  |  -.155092198941101   |   3.527253824330601  |     1.393649071379328E-05   |

|   11  |  -.147688651019029   |   3.674942475349630  |     5.012054146821964E-06   |

|   12  |  -.141287402519622   |   3.816229877869252  |     1.806087799977042E-06   |

|   13  |  -.135677459322946   |   3.951907337192198  |     6.519009073192055E-07   |

|   14  |  -.130705758877762   |   4.082613096069960  |     2.356325011638208E-07   |

|   15  |  -.126258082420783   |   4.208871178490743  |     8.527349871516074E-08   |

|   16  |  -.122247162596666   |   4.331118341087409  |     3.089225602745633E-08   |

|   17  |  -.118604976339413   |   4.449723317426822  |     1.120175154119473E-08   |

|   18  |  -.115277581558855   |   4.565000898985678  |     4.065152835424214E-09   |

|   19  |  -.112221558511077   |   4.677222457496755  |     1.476331599406062E-09   |

|   20  |  -.109401496221224   |   4.786623953717979  |     5.365059182420669E-10   |

|   21  |  -.106788178580707   |   4.893412132298685  |     1.950836921732766E-10   |

|   22  |  -.104357250373633   |   4.997769382672318  |     7.097402769306198E-11   |

|   23  |  -.102088219628453   |   5.099857602300771  |     2.583386350892081E-11   |

|   24  |  -.099963700198069   |   5.199821302498840  |     9.407467587598235E-12   |

|   25  |  -.097968828887871   |   5.297790131386711  |     3.427155500510715E-12   |

|   26  |  -.096090811379261   |   5.393880942765972  |     1.248989274089403E-12   |

|   27  |  -.094318564526427   |   5.488199507292398  |     4.553392776285739E-13   |

|   28  |  -.092642431689816   |   5.580841938982214  |     1.660550395808329E-13   |

|   29  |  -.091053954068989   |   5.671895893051203  |     6.057588083467174E-14   |

|   30  |  -.089545685433508   |   5.761441578484711  |     2.210392180578242E-14   |

|   31  |  -.088111040819299   |   5.849552619304010  |     8.067758865598231E-15   |

|   32  |  -.086744172051496   |   5.936296791355506  |     2.945393142239037E-15   |

|   33  |  -.085439864635133   |   6.021736655990639  |     1.075558153710196E-15   |

|   34  |  -.084193451800155   |   6.105930107790795  |     3.928428426570700E-16   |

|   35  |  -.083000742419381   |   6.188930850210175  |     1.435134781083932E-16   |

|   36  |  -.081857960222931   |   6.270788810433106  |     5.243852455647148E-17   |

|   37  |  -.080761692270354   |   6.351550502703460  |     1.916406368653396E-17   |

|   38  |  -.079708845055539   |   6.431259347758999  |     7.004867396995561E-18   |

|   39  |  -.078696606940469   |   6.509955954699468  |     2.560846408515092E-18   |

|   40  |  -.077722415864772   |   6.587678370564240  |     9.363427819818240E-19   |

|   41  |  -.076783931475456   |   6.664462302039696  |     3.424132883953012E-19   |

|   42  |  -.075879010977721   |   6.740341313017417  |     1.252355670837927E-19   |

|   43  |  -.075005688132458   |   6.815347001149875  |     4.581031059328100E-20   |

|   44  |  -.074162154926178   |   6.889509156076053  |     1.675925065379068E-20   |

|   45  |  -.073346745519811   |   6.962855901595864  |     6.131959567870347E-21   |

|   46  |  -.072557922148334   |   7.035413823744198  |     2.243855953915368E-21   |

|   47  |  -.071794262696574   |   7.107208086440772  |     8.211821433989183E-22   |

|   48  |  -.071054449720253   |   7.178262536161025  |     3.005597474419474E-22   |

|   49  |  -.070337260717363   |   7.248599796878388  |     1.100188302574742E-22   |

|   50  |  -.069641559484704   |   7.318241356363092  |     4.027599883464495E-23   |

|   51  |  -.068966288419143   |   7.387207644782235  |     1.474575511225216E-23   |

|   52  |  -.068310461643722   |   7.455518106425957  |     5.399176490910951E-24   |

|   53  |  -.067673158856003   |   7.523191265281959  |     1.977089544270664E-24   |

|   54  |  -.067053519810499   |   7.590244785092459  |     7.240391424659438E-25   |

|   55  |  -.066450739359246   |   7.656695524451705  |     2.651754423890896E-25   |

|   56  |  -.065864062984884   |   7.722559587436589  |     9.712674656646382E-26   |

|   57  |  -.065292782769385   |   7.787852370205974  |     3.557766673118480E-26   |

|   58  |  -.064736233749010   |   7.852588603954984  |     1.303310897234678E-26   |

|   59  |  -.064193790612443   |   7.916782394567427  |     4.774736971311116E-27   |

|   60  |  -.063664864704508   |   7.980447259271935  |     1.749366128853753E-27   |

Après 60 itération(s), les approximations successives

semblent diverger, soit par oscillation ou soit vers ± l'infini.

Essayer, s'il y a lieu, une autre valeur d'amorce plus près 

du zéro réel à localiser et/ou augmenter le nombre d'itérations.

>

Le procédé de Newton-Raphson est donc vraisemblablement mis en échec dans ce cas. En effet, exécutez l'animation suivante qui montre le comportement des six premières approximations successives avec = 0,52.

>

Choisissons maintenant = 0,48 comme valeur d'amorce.

> newton(f,amorce=0.48,n=10,E=0.00001,non);

La méthode de Newton-Raphson converge.

La valeur initiale x[0] = .4800000000000 a permis de trouver

le zéro réel approximatif r = .000000000000000 avec E =  .000010000000000

Cela a nécessité 6 itérations.

>

Le procédé de Newton-Raphson dans ce cas converge. Ces deux derniers développements montrent que la méthode de Newton-Raphson est parfois sensible au choix de la valeur d'amorce .

La méthode de Newton-Raphson est plutôt efficace en terme de vitesse de convergence mais il n'y a pas de garantie de convergence. Et, lorsqu'il y a convergence, ce n'est pas nécessairement vers la valeur à laquelle on pense. L'exemple suivant va illustrer une telle situation.

Soit la fonction f définie par .

> f:=x->8*x^4-14*x^3-9*x^2+11*x-1;
plot([x,f(x),x=-2..2],color=orange,thickness=2,numpoints=80,
xtickmarks=12,view=[-2..2,-12..14]);

>

> newton(f,amorce=0.37,n=20,E=0.00001,oui);

Méthode de Newton-Raphson

La valeur initiale donnée est x[0] =  .3700000000000

|   k   |      x[k+1]-x[k]     |        x[k]       |              f(x[k])          | 

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

|    1  |   6.057390381627316   |  -5.687390381627316  |     1.059117580997774E+04   |

|    2  |  -1.484999108572100   |  -4.202391273055217  |     3.327868431511312E+03   |

|    3  |  -1.098325036777342   |  -3.104066236277875  |     1.039556420040468E+03   |

|    4  |  -.802823998663243   |  -2.301242237614632  |     3.209958920500422E+02   |

|    5  |  -.573234686886415   |  -1.728007550728217  |     9.668574828000756E+01   |

|    6  |  -.389197390466775   |  -1.338810160261441  |     2.743912280729513E+01   |

|    7  |  -.234576236242642   |  -1.104233924018799  |     6.623606187415767E+00   |

|    8  |  -.104437924912860   |  -.999795999105940  |     9.908233303023140E-01   |

|    9  |  -.022034475606762   |  -.977761523499177  |     3.882314129580868E-02   |

|   10  |  -.000936281087436   |  -.976825242411742  |     6.829977424734223E-05   |

|   11  |  -.000001652970842   |  -.976823589440900  |     2.126492995648971E-10   |

La méthode de Newton-Raphson converge.

Le zéro réel approximatif est r =-.976823589440900 avec E =  .000010000000000

>

On constate donc que le zéro réel trouvé, soit r » - 0,97682, n'est pas l'un des deux situés à proximité de l'amorce = 0,37. Pouvez-vous expliquer pourquoi ?

Lancer l'animation suivante. Cela devrait vous mettre sur la piste de la réponse.

>