Discussion :

[Sve@r]

ne croyez pas que je fais rien vu les erreurs bêtes qu'il y a dans mon code

Absolument pas. Je te promets que les boulets qui branlent que dalle en se contentant de geindre et de dire "je ne vois pas comment faire" je ne reste pas avec eux (d'ailleurs eux non plus ne restent pas avec moi ). Faire des erreurs c'est naturel. Après ok je te casse un peu mais comme ça tu n'oublieras pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
def poly_produit(poly_1,poly_2):
 
    Poly_produit_1 = poly_simple(poly_1[:])
    Poly_produit_2 = poly_simple(poly_2[:])
    Produit = [0] * (len(Poly_produit_1)+len(Poly_produit_2)+1)
    for (i,a) in enumerate(Poly_produit_1):
     for (j,b) in enumerate(Poly_produit_2):
      Produit[i+j] += a * b
    return poly_simple((Produit))

Joli !!! Là il y a la matière et aussi la manière. Je ne peux pas te donner mieux, mon code est exactement le même (juste j'utilise list(poly) un poil plus rapide que poly[:] pour copier mon polynome). En plus le renversement dont j'ai parlé précédemment (il correspondait à l'application bête de l'algo expliqué dans le pdf) est inutile vu que ça marche qu'on fasse le truc dans un sens ou dans l'autre.

Qui fonctionne malgré un petit soucis. J'utilise donc poly_simple pour enlever tous les 0 inutiles mais la fonction renvoie quand même des 0 inutiles.

Par exemple pour l'appel de la fonction poly_produit([1, 3, 3, 1], [1, 1]) -> [1, 4, 6, 4, 1, 0, 0] au lieu de [1, 4, 6, 4, 1]

Hé oui, poly_simple supprime les zéros placés au début du polynome, pas ceux placés à la fin. Maintenant si tu lis bien ce que j'avais écrit précédement "créer un polynome rempli de 0 et ayant pour longueur la somme des longueurs des 2 polynomes à multiplier - 1" c'est pas exactement ce que t'as codé. [1, 3, 3, 1] * [1, 1] donnera un polynome de longueur 5, pas 7. Ou alors 7 si tu veux mais avec 2 zéros. Ok vu le reste on oubliera très vite cette petite erreur.

Courage, quand tu auras fini (reste encore la dérivée) je te donnerai mon code perso de ce TP.

[Avi.Py]

Joli !!! Là il y a la matière et aussi la manière. Je ne peux pas te donner mieux, mon code est exactement le même (juste j'utilise list(poly) un poil plus rapide que poly[:] pour copier mon polynome). En plus le renversement dont j'ai parlé précédemment (il correspondait à l'application bête de l'algo expliqué dans le pdf) est inutile vu que ça marche qu'on fasse le truc dans un sens ou dans l'autre.

Pour une fois que j'ai vraiment compris


Je m'y met de suite pour la dérivée

[Avi.Py]

Ce serait pas marrant si je comprenais tout du 1er coup donc bon c'est parti pour un code à 2 balles

Je comprend le principe : multiplier chaque élément par son indice associé et le placer au rang inférieur
Mais après ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def poly_derive(poly) :
 
    Poly_derivee = []
 
    for n in range(-1,-len(poly)-1,-1): ## On reconstruit la liste à l'envers et on a donc la liste parcourure de la droite vers la gauche
      Poly_derivee=(Poly_derivee[n])*[n] ## Je sais que cette ligne veut absolument rien dire mais je ne comprend pas comment multiplier chaque terme par son indice
    return Poly_derivee

[Sve@r]

Je comprend le principe : multiplier chaque élément par son indice associé et le placer au rang inférieur
Mais après ...

Ben après tu le codes !!! Quand on a fait la multiplication, recopier une liste 1 dans une liste 2 en décalant d'un rang et en modifiant un peu les valeurs recopiées ça devrait être peanut. A la limite tu fais comme pour la multiplication: tu crées la liste finale dès le départ à la bonne taille et ensuite tu la remplis...

## On reconstruit la liste à l'envers et on a donc la liste parcourure de la droite vers la gauche

A tout hasard...reversed() ???

## Je sais que cette ligne veut absolument rien dire mais je ne comprend pas comment multiplier chaque terme par son indice

Ben oui, c'est ça, sauf qu'il faut restocker le résultat dans Poly_derive (append).... Un peu de fatigue probablement car tu l'as fait plein de fois.
Et attention à l'usage des parenthèses. Elles servent à prioriser des opérations, pas des valeurs. Ecrire (2) * X (ou (Poly_derivee[n])* X) ça ne sert à rien face à 2 * X. D'autant plus quand tu écris [n] avec des crochets ce qui en fait alors une liste !!!

[marco056]

T'as remarqué qu'il écrase son res_produit à chaque itération ?

Non, je n'avais pas vu.

[Avi.Py]

J'ai continué et j'ai donc fini par obtenir le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def poly_derive(poly) :
    Poly_derivee=[]
    Poly_der = poly_simple(poly[:])
    Poly_der.reverse()
 
    for i in range(len(Poly_der)):
      Poly_derivee.append(Poly_der[i]*i)
    Poly_derivee.reverse()
    Poly_derivee.pop()
    print (Poly_derivee)

QUI MARCHE !!! Peut être pas la version la plus optimale mais j'ai fais de mon mieux

Il me reste donc un seul code, celui de poly_newton(poly, x0, iter_max, precision) : Recherche de racine par la méthode de Newton.

Exemples :

• isclose( poly_newton([1, 0, -2], 1, 100, 1e-9), sqrt(2), abs_tol=1e-9 ) → True
• isclose( poly_newton([1, 0, -2], -1, 100, 1e-9), -sqrt(2), abs_tol=1e-9) → True
• poly_newton([], 0, 100, 1e-9) -> None
• poly_newton([1], 0, 100, 1e-9) -> None
• isclose( poly_newton([1, 0], 1, 100, 1e-9), 0.0, abs_tol=1e-9) → True
• isclose( poly_newton([1, 0, 0, 0, 0, -2], 1, 100, 1e-9), 2**(1/5), abs_tol=1e-9)→ True

Allez je m'y remet, c'est bientôt la fin !

[Sve@r]

QUI MARCHE !!!

Ok, pour que ça marche tout à fait, rajoute un return Poly_derivee à la fin.

Peut être pas la version la plus optimale mais j'ai fais de mon mieux

Non, tu n'as pas fait de ton mieux. Tu aurais écrit Poly_der = poly_simple(poly[:-1]) tu n'avais pas besoin de popper le dernier élément. Ou alors tu retournais simplement Poly_derivee[:-1] (le pop inplique un travail de modification qui prend du temps). Et tu aurais écrit Poly_der = reversed(poly_simple(poly[:-1])) tu évitais une affectation pour rien. Et puisque len() sait calculer la longueur d'un objet "en live", tu aurais pu partir directement sur for i in range(len(reversed(poly_simple(poly[:-1])))). Tout ça tu le connaissais. Ok faire un code qui fonctionne c'est bien et c'est pas grave si tu ne visualises immédiatement comment le faire directement en plus simple mais faire de son mieux, c'est une fois que le code est là, alors le reprendre étape par étape pour voir tout ce qui peut se simplifier.
Ce qui est bien c'est que tu bosses à 6h du mat. Allez, cadeau.

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def poly_derive(poly) :
	derivee = []
	for (i, p) in enumerate(reversed(poly[:-1]), 1):
		derivee.append(p * i)
	return list(reversed(derivee))

Il me reste donc un seul code, celui de poly_newton(poly, x0, iter_max, precision) : Recherche de racine par la méthode de Newton.

Explications détaillées ici: https://www.lyceedadultes.fr/siteped...hme_newton.pdf

[Avi.Py]

Je ne sais pas vraiment si je suis sur la bonne voie...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
## EX 8
 
def poly_newton(poly, x0, iter_max, precision):
 
    if poly_degre(poly)<=0:
      return None 
 
    x = x0 # Initialisation
    while abs(poly) > precision: # Tant que |poly| > précision choisi
      derivee_Newton = (poly*(x+iter_max)-(poly))/iter_max # dérivée en x_k par taux d’accroissement
      x = x - poly/derivee_Newton # nouvelle valeur x_{k+1} de x
    return x # Renvoie de la valeur finale

[Sve@r]

Je ne sais pas vraiment si je suis sur la bonne voie...

Sais pas trop non plus. Déjà tes tests reflètent ce que tu comprends des objets que tu manipules. Et qui sont pour l'instant des objets que tu as créé (plus tard tu devras manipuler des objets créés par d'autres) donc que tu devais maîtriser à la perfection. Par exemple if poly_degre(poly)<=0. Le degré d'un polynome (sa longueur) peut-il être inférieur à 0?
Ensuite qu'attends-tu quand tu écris poly*(x+iter_max)-(poly) (multiplier un polynome (donc en réalité une liste de nombres) par une valeur) avec encore ces parenthèses autour de "poly" alors que je t'ai dit que les parenthèses servent à prioriser une opération !!!!
En plus l'instruction est possible mais ne fait pas ce que je présume que tu en attends ([1, 2, 3] * 2 => [1, 2, 3, 1, 2, 3] et tu connaissais ce résultat puisque tu l'avais écrit dans Produit = [0] * (len(Poly_produit_1)+len(Poly_produit_2)+1). Ce TP est fait pour que tu progresses en t'appuyant sur les exercices précédents qui t'apprennent à créer des choses et à les manipuler.

Le souci que moi j'ai c'est que je ne pige pas trop ce que représentent les paramètres x0, iter_max et precision. Ou (dit autrement), quelles sont les indications qu'on t'a donné pour calculer la méthode de Newton?

[MPython Alaplancha]

Absolument pas. Je te promets que les boulets qui branlent que dalle en se contentant de geindre et de dire "je ne vois pas comment faire" je ne reste pas avec eux (d'ailleurs eux non plus ne restent pas avec moi ).

Bonjour,
Perso, ce type de propos condescendants, hautains et méprisants me choque.
Traiter une personne de boulet est méprisant.
Quel bel accueil fait à cet étudiant pour son premier message!
Ce n'est malheureusement pas la première fois que ça dérape vers l'irrévérencieux

N'y a t'il aucun modérateur sur ce site?
(je veux bien postuler )

[wiztricks]

Perso, ce type de propos condescendants, hautains et méprisants me choque.
Traiter une personne de boulet est méprisant.

Sortir quelque chose de son contexte pour lui faire dire le contraire s'appelle de la diffamation (et c'est puni par la loi).

- W

[MPython Alaplancha]

Sortir quelque chose de son contexte pour lui faire dire le contraire s'appelle de la diffamation (et c'est puni par la loi).

- W

moué .. J'interviens aujourd'hui ,mais j'aurais pu le faire de nombreuses fois... D'ailleurs c'est décidé, j'interviendrai maintenant à chaque propos déplacé, à chaque manque de respect, à chaque bizutage..

[Avi.Py]

Sais pas trop non plus. Déjà tes tests reflètent ce que tu comprends des objets que tu manipules. Et qui sont pour l'instant des objets que tu as créé (plus tard tu devras manipuler des objets créés par d'autres) donc que tu devais maîtriser à la perfection. Par exemple if poly_degre(poly)<=0. Le degré d'un polynome (sa longueur) peut-il être inférieur à 0?
Ensuite qu'attends-tu quand tu écris poly*(x+iter_max)-(poly) (multiplier un polynome (donc en réalité une liste de nombres) par une valeur) avec encore ces parenthèses autour de "poly" alors que je t'ai dit que les parenthèses servent à prioriser une opération !!!!
En plus l'instruction est possible mais ne fait pas ce que je présume que tu en attends ([1, 2, 3] * 2 => [1, 2, 3, 1, 2, 3] et tu connaissais ce résultat puisque tu l'avais écrit dans Produit = [0] * (len(Poly_produit_1)+len(Poly_produit_2)+1). Ce TP est fait pour que tu progresses en t'appuyant sur les exercices précédents qui t'apprennent à créer des choses et à les manipuler.

Le souci que moi j'ai c'est que je ne pige pas trop ce que représentent les paramètres x0, iter_max et precision. Ou (dit autrement), quelles sont les indications qu'on t'a donné pour calculer la méthode de Newton?

Voilà l'énoncé :

En analyse numérique, la méthode de Newton ou méthode de Newton-Raphson est, dans son application la plus simple, un algorithme efficace pour trouver numériquement une approximation précise d'un zéro (ou racine) d'une fonction réelle d'une variable réelle
Ici, on va s'en servir pour recherche/approcher les racines d'un polynôme.
La méthode est itérative, elle consiste à calculer la suite de valeurs :
xk+1=xk−P(xk)/ P'(xk), où x0 est passé en paramètre et P'(X) est le polynôme dérivé de P(X).
Ainsi, à partir de x0 donné, on va s'approcher successivement d'une racine.
On donne, en plus de P(X) et de la valeur x0, un entier `iter_max` et une précision `precision`.
Il y a deux conditions d'arrêt de l'algorithme :
• soit xk est assez proche d'une racine, c'est-à-dire que abs(P(xk)) < precision
• soit k est supérieur à iter_max itération, auquel cas la méthode ne converge pasSi on a pu approcher une racine, on la renvoie. Sinon, si on a épuisé le nombre d'itérations sans succès et on renvoie `None`.
Par exemple, on cherche une racine de P(X)=X²−2 à proximité de 1, à 10^-4 près, avec `poly_newton([1, 0, -2], 1, 100, 1e-4)`, les étapes sont les suivantes :
• on calcule P'(X) = 2*X
• itération i=0 : x=+1.0000, P(+1.0000)=-1.0000 et P'(+1.0000)=+2.0000
• itération i=1 : x=+1.5000, P(+1.5000)=+0.2500 et P'(+1.5000)=+3.0000
• itération i=2 : x=+1.4167, P(+1.4167)=+0.0069 et P'(+1.4167)=+2.8333
• itération i=3 : x=+1.4142, P(+1.4142)=+0.0000 et P'(+1.4142)=+2.8284

Paramètres:

• poly : list[int], le polynôme dont on cherhe les racines
• x0 : float, la valeur initiale vers laquelle on cherche
• iter_max : int, le nombre maximum (inclu) d'étapes
• precision : float, la précision (typiquement 1e-6 ou 1e-9)

Résultat :

• None or float : Renvoie None en cas de divergence ou si le polynôme n'est pas de degré suffisant. Sinon, renvoie une racine approchée en cas de convergence


J'avoue avoir du mal sur celui la. J'ai cherché sur le net et la plupart des code que je trouve font appel a des bibliothèques que je n'ai pas le droit d'utiliser. Du coup j'ai essayé de bidouiller quelque chose mais sa reste quand même assez flou.

EDIT

J'ai continué de travailler sur le code mais je n'arrive jamais a obtenir les racines. Voici quelques codes que j'ai fais mais aucun d'entre eux ne fonctionne.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def poly_newton(poly, x0, iter_max, precision):
 
 
    xn , L = x0, [] 
    for Ph in range(iter_max):
       polyxn=poly(xn)
       if abs(polyxn)<precision:
        return xn, L
       L.append(xn)
       xn=xn-poly/poly_derive(polyxn)
    print (" Erreur , l’algorithme n’a pas convergé après ", iter_max , " itérations ")

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def poly_newton(poly, x0, iter_max, precision):
 
 
    x=x0
    y=x0-poly(x0)/poly_derive(x0) 
    for Ph in range(iter_max):
      while abs(y-x) > precision:
        x=y
        y=x-poly(x)/poly_derive(x)
      return y

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def poly_newton(poly, x0, iter_max, precision):
 
    if precision <= 0 :
      raise ValueError("precision doit être strictement positif")
    for _ in range(iter_max) :
# Détermination du terme suivant dans la suite
      xn=x0-poly/poly_derive(poly)
# Arrêt car la suite n'évolue plus
    if abs(xn-x0) < precision :
      return xn
# Mise à jour de x
    x = xn
# Arrêt car on a atteint le nombre maximal d'itérations
    return x

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def poly_newton(poly, x0, iter_max, precision):
 
     if precision <= 0 : 
        raise ValueError("precision doit être strictement positif")
     for Ph in range(iter_max):   
       u=x0
       v=u-poly(u)/poly_derive(u)
       while abs(v-u)>precision:
         u,v=v,v-poly(v)/poly_derive(v)
       return v

[Sve@r]

Perso, ce type de propos condescendants, hautains et méprisants me choque.

Tu as un bouton pour ça. Tu l'as utilisé?

Quel bel accueil fait à cet étudiant pour son premier message!

Son accueil il l'a eu. On lui a donné des solutions et orientations. Peut-être pas de la façon que tu aurais aimé voir mais il a eu une aide (toutefois aucune venant de toi). A-t-il donné suite? C'est lui plutôt le malpoli. Autant il y a le "bonjour" autant il devrait y avoir un "au revoir". Tu peux regarder mes discussions, à chaque fois que j'ai posé une question j'ai toujours veillé à venir donner la conclusion (même si parfois il n'y en avait pas alors je l'ai dit) et remercier ceux qui avaient répondu.

N'y a t'il aucun modérateur sur ce site? (je veux bien postuler )

Ah? Attiré par le pouvoir de la modération sous couvert de "protéger les autres"? J'ai une curieuse impression de "déjà vu"...

D'ailleurs c'est décidé, j'interviendrai maintenant à chaque propos déplacé, à chaque manque de respect, à chaque bizutage..

Bravo (ceci dit c'était déjà prévu dans les règles)...

[I]En analyse numérique, la méthode de Newton ou méthode de Newton-Raphson est, dans son application la plus simple, un algorithme efficace pour trouver numériquement une approximation précise d'un zéro (ou racine) d'une fonction réelle d'une variable réelle
Ici, on va s'en servir pour recherche/approcher les racines d'un polynôme.
La méthode est itérative, elle consiste à calculer la suite de valeurs :
xk+1=xk−P(xk)/ P'(xk), où x0 est passé en paramètre et P'(X) est le polynôme dérivé de P(X).
Ainsi, à partir de x0 donné, on va s'approcher successivement d'une racine.
On donne, en plus de P(X) et de la valeur x0, un entier `iter_max` et une précision `precision`.
Il y a deux conditions d'arrêt de l'algorithme :
• soit xk est assez proche d'une racine, c'est-à-dire que abs(P(xk)) < precision
• soit k est supérieur à iter_max itération, auquel cas la méthode ne converge pasSi on a pu approcher une racine, on la renvoie. Sinon, si on a épuisé le nombre d'itérations sans succès et on renvoie `None`.

Ok, j'ai mis en rouge les éléments importants. Il y a

• calculer P(x) et P'(x)
• s'arrêter quand on n'y arrive pas
• s'arrêter quand on a trouvé

Tu as remarqué que tout ce TP était fait pour t'apprendre à construire des briques servant ensuite de bases pour l'exo suivant? Tout d'abord une fonction qui supprime les zéros non significatifs, ce qui te permet d'avoir le degré réel. Puis une fonction qui complète avec des zéros et, hasard, pour l'addition il fallait compléter. Puis on t'a demandé une fonction qui calcule la dérivée et, ah tiens? l'algorithme de Newton a besoin de la dérivée. Et puis une fonction qui évalue un polynome (quel qu'il soit) en un point X et, ah tiens? l'algorithme de Newton demande la division de P(x) par P'(x) (donc l'évaluation de x par P divisé par l'évaluation de x par P').

Ton second code (le premier est à oublier) montre que tu as compris l'idée (je m'appuie sur cette ligne y=x0-poly(x0)/poly_derive(x0)). Sauf que t'as encore du mal à l'appliquer. Coup de pouce: l'évaluation de x0 ce n'est pas poly(x0) mais poly_eval(poly, x0). Ce que je trouve dommage c'est que je n'aurais pas dû avoir besoin de te le dire.

[Avi.Py]

Ok, j'ai mis en rouge les éléments importants. Il y a

• calculer P(x) et P'(x)
• s'arrêter quand on n'y arrive pas
• s'arrêter quand on a trouvé

Tu as remarqué que tout ce TP était fait pour t'apprendre à construire des briques servant ensuite de bases pour l'exo suivant? Tout d'abord une fonction qui supprime les zéros non significatifs, ce qui te permet d'avoir le degré réel. Puis une fonction qui complète avec des zéros et, hasard, pour l'addition il fallait compléter. Puis on t'a demandé une fonction qui calcule la dérivée et, ah tiens? l'algorithme de Newton a besoin de la dérivée. Et puis une fonction qui évalue un polynome (quel qu'il soit) en un point X et, ah tiens? l'algorithme de Newton demande la division de P(x) par P'(x) (donc l'évaluation de x par P divisé par l'évaluation de x par P').

Ton second code (le premier est à oublier) montre que tu as compris l'idée (je m'appuie sur cette ligne y=x0-poly(x0)/poly_derive(x0)). Sauf que t'as encore du mal à l'appliquer. Coup de pouce: l'évaluation de x0 ce n'est pas poly(x0) mais poly_eval(poly, x0). Ce que je trouve dommage c'est que je n'aurais pas dû avoir besoin de te le dire.

C'est censé donner quelque chose qui ressemble à ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
def poly_newton(poly, x0, iter_max, precision):
 
    x=x0
    y=x-poly_eval(poly,x0)/poly_eval(poly_derive(poly),x0) 
    for Ph in range(iter_max):
        while abs(poly_eval(poly,x0)) > precision:
         x=y
         y=x-poly_eval(poly,x0)/poly_eval(poly_derive(poly),x0) 
        return y

[MPython Alaplancha]

Tu as un bouton pour ça. Tu l'as utilisé?

Non. En fait, je viens de découvrir son existence aujourd'hui en désactivant NoScript...
C'est effectivement ce que j'aurais dû entreprendre au lieu d'intervenir sur la discussion du PO.

Je tiens à préciser que ce sont tes propos qui m'ont choqué, je ne juge en aucun cas ta personne...
Sujet clos pour moi

[Sve@r]

C'est censé donner quelque chose qui ressemble à ça ?

Je n'ai pas encore écrit le code de mon côté mais oui ça ressemble. Accessoirement la boucle interne peut disparaitre, tu peux tout faire dans une simple boucle principale, à la fois regarder si tu as trouvé, et à la fois si la solution est impossible. Suffit de faire une boucle infinie et si un cas se présente alors sortir de la boucle avec telle valeur, si un autre cas se présente alors sortir de la boucle avec telle autre valeur.
Reste tout de même cette poly_derive que tu utilises bien mal. Si l'évaluation de x0 via poly s'écrit d'une certaine manière, l'évaluation de x0 via sa dérivée doit s'écrire d'une manière similaire (la dérivée d'un polynôme ça reste un polynôme !!!)

Je tiens à préciser que ce sont tes propos qui m'ont choqué, je ne juge en aucun cas ta personne...

Très honnête de ta part. Effectivement on ne peut pas juger quelqu'un sur un propos (ni plusieurs), on ne peut juger qu'en connaissant.

[Avi.Py]

Je n'ai pas encore écrit le code de mon côté mais oui ça ressemble. Accessoirement la boucle interne peut disparaitre (tu peux tout faire dans une simple boucle principale, à la fois regarder si tu as trouvé, et à la fois si la solution est impossible). Suffit de faire une boucle infinie et si un cas se présente alors sortir de la boucle avec telle valeur, si un autre cas se présente alors sortir de la boucle avec telle autre valeur
Reste tout de même cette poly_derive que tu utilises bien mal. Si l'évaluation de x0 via poly s'écrit d'une certaine manière, l'évaluation de x0 via sa dérivée doit s'écrire d'une manière similaire (la dérivée d'un polynome ça reste un polynome !!!)

Okay je vais essayer de reprendre ça, je vois enfin la fin du tunnel

[Avi.Py]

J'obtiens donc ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def poly_newton(poly, x0, iter_max, precision):
    x=x0
    Pk=poly_eval(poly,x0)
    Pk_prime=poly_eval(poly_derive(poly),x0) 
    while abs(Pk) < precision in range(iter_max):
      y=x-Pk/Pk_prime 
      x=y
      return y
    else:
      return None

[Sve@r]

J'obtiens donc ce code

C'est presque ça. Sauf qu'il faut réévaluer le x en cours via P et aussi via P' à chaque itération. Enfin c'est ce qui est écrit ici "xk+1=xk−P(xk)/ P'(xk)".
J'aime bien ton else pour le while. Moi j'ai mis un paquet d'années avant de savoir qu'on pouvait mettre un else sur les boucles. Sauf que, là encore avec un peu de réflexion, tu verras qu'il ne sert à rien, et en Python on aime bien la simplicité. On pourrait même supprimer aussi le return None (une fonction qui ne retourne rien retourne None par défaut) mais je pense que ce serait exagéré (il faut se méfier des comportements par défaut car ils ne nous sautent pas à la figure quand on relit son code).
En revanche j'aime moins while condition in range(...). Python l'accepte mais je n'ai absolument aucune idée de comment il la comprend

Encore un détail (j'ai écrit le code donc j'ai vu certains soucis) il peut arriver que P'(x) vaille zéro. J'ai en effet bêtement tenté de résoudre x²-7x+12 avec x0=3.5 (c'est mon équation test car ses deux solutions sont 3 et 4) sauf que sa dérivée c'est 2x-7 qui vaut 0 quand x vaut 3.5. Et diviser par 0...