Discussion :

[jojo5457]

Bonjour j'aurais besoin d'un petit peu d'aide je dois écrire un programme en python et je n'y arrive pas. Voila l’énoncer:

On considère la fonction f définie sur [4,6] par f(x)=-0,2x^3+x^2+0.5x+1.
La propriété des valeurs intermédiaires nous permet d’affirmer que l’équation f(x)=0 admet une unique solution alpha
sur [4,6].
Ecrire un programme en Python permettant de « résoudre » par dichotomie l’équation f(x)=0 en obtenant une valeur approchée de alpha a 10^-n.
La fonction f sera définie comme une fonction dans le programme python.
Les nombre les bornes de l’intervalle initial a et b seront saisies par l’utilisateur, ainsi que k (dans notre exemple k=0) et n fixant la précision de la valeur approchée (à 10^-n).
Pour tester le programme, on pourra ensuite lancer d’autres résolutions comme celle de l’équation f(x)=2.

Et voila ce que j'ai fait:

def f(x):
return -0.2*x*x*x+x*x+0.5*x+1
A = input("A = ")
B = input("B = ")
N = input("Precision = ")

if f(A)*f(B)>0 :
print("pas de racine entre ",A," et ",B)
else:
while B-A>=N :
C =(A+B)/2
if f(C)*f(B)<=0 :
B=C
else :
A=C
print("Une racine entre ",A, "et ",B)


Merci d'avance

[plxpy]

Bonjour

il y a plusieurs choses qui ne vont pas dans ce que tu fais.

Evacuons ça tout de suite : la forme. Quand tu postes sur le forum, utilise le bouton '#' qui te mettra les balises début et fin et tape (ou colle) ton code entre ces deux balises. C'est beaucoup plus lisible comme ça (surtout que l'indentation fait partie intégrante de Python).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def f(x):
    return -0.2*x*x*x+x*x+0.5*x+1
 
A = input("A = ")
B = input("B = ")
N = input("Precision = ")
 
if f(A)*f(B)>0 :
    print("pas de racine entre ",A," et ",B)
else:
    while B-A>=N :
        C =(A+B)/2
        if f(C)*f(B)<=0 :
            B=C
        else :
            A=C
 
    print("Une racine entre ",A, "et ",B)

Sur le fond maintenant.

Déjà, tu utilises les signes des résultats de la fonction aux extrémités de l'intervalle pour déterminer quelle extrémité tu vas changer par l'abscisse du milieu (C).

Ca marche au début parce que l'ennoncé te demande de chercher une solution à f(x) = 0. Mais, à la fin, il est demandé de tester le programme pour chercher la solution de f(x) = 2. Ca marchera beaucoup moins bien ...


Ensuite (je reste dans le cas où on cherche la solution de f(x)=0 sans me soucier de celle de f(x)=2), ton changement d'une extrémité de l'intervalle se passe mal. Si tu ne le vois pas "à l'oeil", affiche les valeurs qui te permettront de t'en rendre compte (valeurs de A, f(A), C, f(C), B et f(B)) avant et/ou après modifications, aux bons endroits.

Enfin, tant que tu n'as pas validé ton code, je te conseille aussi de coder en dur tes valeurs A, B et N ce qui t'évitera d'avoir à saisir à chaque exécution les valeurs (et commente les instructions input). Tu te conformeras à l'ennoncé en remettant les input pour la saisie à la fin. Tu peux aussi prendre une valeur pas trop petite pour la précision car, sinon, cela va te générer des tonnes de lignes d'affichage (0.1 fera l'affaire pour commencer)

Ah oui, j'allais oublier : c'est bien parce que l'ennoncé te donne les noms de variables à utiliser mais A, B, N et F, c'est pas terrible ...


[EDIT] pour être complet, si epsilon représente la précision demandée, ton test while peut porter sur 2 x epsilon en prenant le milieu comme solution (que tu n'affiches jamais dans ton code, d'ailleurs). Ca ne fait gagner évidemment qu'une itération (sur ...) mais comme on fait des maths ...

[jojo5457]

Merci de m'avoir répondu mais j'ai pas très bien compris se que je dois changer pour que sa marche avec f(x)=2 ?

[plxpy]

Sur [4;6], la fonction est décroissante.

Dans ton code, à chaque itération, tu calcules le signe de f(C) x f(B) et en déduis s'il faut remplacer la borne min (A) par C (le milieu) ou la borne max (B) par C. Ca va marcher parce que, pour x < alpha, f(x) est positif, et après, pour alpha < x, f(x) est négatif.

Avec le même code, si tu cherches la solution de f(x) = 2, quand tu te rapprocheras de alpha (intervalle suffisamment petit autour de alpha), tu vas avoir des valeurs f(x) proches de ... 2 c'est-à-dire toutes les deux positives. Donc le calcul de signe n'a plus de sens. Ce n'est pas le signe de f(x) qu'il faut prendre en compte.

Sinon, as-tu bien vu que tu te trompes sur le choix de la borne, A ou B, à remplacer par le milieu C ?

[Sve@r]

Merci de m'avoir répondu mais j'ai pas très bien compris se que je dois changer pour que sa marche avec f(x)=2 ?

Salut
Ben au lieu de regarder le signe de f(A) * f(B) te suffit de regarder si le but (ici 2) se trouve entre f(A) et f(C) ou bien entre f(C) et f(B).
Ensuite, selon le cas, tu places A ou B à la place de C puis tu recalcules un nouveau C et tu recommences. C'est quand-même la base du principe de la recherche par dichotomie quoi

[plxpy]

En modifiant un peu ton code (bon choix de la borne à remplacer), avec un epsilon (N) à 1e-3, MAIS toujours sans tenir compte du fait qu'on cherche f(x) = 2, j'obtiens :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
plx@sony:~$ python3 faux_dicho.py 
iteration  1 : f(A) = +6.200000  f(C) = +3.500000  f(B) = -3.200000   : f(C) x f(A) > 0 => A devient C
iteration  2 : f(A) = +3.500000  f(C) = +0.725000  f(B) = -3.200000   : f(C) x f(A) > 0 => A devient C
iteration  3 : f(A) = +0.725000  f(C) = -1.084375  f(B) = -3.200000   : f(C) x f(A) < 0 => B devient C
iteration  4 : f(A) = +0.725000  f(C) = -0.142578  f(B) = -1.084375   : f(C) x f(A) < 0 => B devient C
iteration  5 : f(A) = +0.725000  f(C) = +0.300342  f(B) = -0.142578   : f(C) x f(A) > 0 => A devient C
iteration  6 : f(A) = +0.300342  f(C) = +0.081183  f(B) = -0.142578   : f(C) x f(A) > 0 => A devient C
iteration  7 : f(A) = +0.081183  f(C) = -0.030120  f(B) = -0.142578   : f(C) x f(A) < 0 => B devient C
iteration  8 : f(A) = +0.081183  f(C) = +0.025675  f(B) = -0.030120   : f(C) x f(A) > 0 => A devient C
iteration  9 : f(A) = +0.025675  f(C) = -0.002186  f(B) = -0.030120   : f(C) x f(A) < 0 => B devient C
iteration 10 : f(A) = +0.025675  f(C) = +0.011754  f(B) = -0.002186   : f(C) x f(A) > 0 => A devient C
racine 5.6044921875 trouvée en 10 iterations  f(alpha) = 0.004786

alpha valant plutôt 5.6051626015105285 (donc je suis bien à 10-3 près)

En fait, ça continue de chercher la racine de f(x) = 0 ...

Nulle part tu n'as (cf l'ennoncé) la variable K

...par l’utilisateur, ainsi que k (dans notre exemple k=0)...
Pour tester le programme, on pourra ensuite lancer d’autres résolutions comme celle de l’équation f(x)=2.

Qu'est-ce qui va changer de signe aux alentours de alpha ? f(x) ? ou f(x) ... ?

[plxpy]

Une image comme piste.

résoudre f(x) = 2 c'est résoudre, en posant g(x) = f(x)-2, g(x) = 0

Avec la "nouvelle" fonction g, on se remet dans les conditions pour avoir des valeurs g(x) qui changent de signe autour de la racine ...


en vert, le fonction f
en rouge, la fonction g
en magenta, la fonction y = 2

la droite verticale bleue passe par l'intersection de f et de y=2.

On dirait bien qu'elle passe aussi par l'intersection de g et de y = 0 ...

[plxpy]

J'arrête là le suspens.

A la racine de f(x) = K

(quand elle existe - ici c'est toujours vrai tant que k est dans [f(A);f(B)])

c'est f(x)-K qui change de signe :

sur [ A ; alpha [ , f(x) > K <==> f(x) - K > 0
sur ] alpha ; B ] , f(x) < K <==> f(x) - K < 0

La méthode de Sve@r est tout à fait correcte et est plus générale (on n'a pas toujours une jolie fonction mathématique qui se prête bien à une approche purement ... mathématique).

Mais comme, tu es partie sur les signes des valeurs, j'ai poursuivi sur cette voie et, ici , il faudra regarder le signe du produit ( f(A)-K ) * ( f(C) - K)
on peut remplacer A par B et calculer l'équivalent


Maintenant, ton erreur dans le choix de la borne à remplacer dans ton code :

Code :

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

1
2
3
4
if f(C)*f(B)<=0 :
        B=C
    else :
        A=C

(là tu ne prenais pas en compte la valeur K et resolvais f(x) = 0)

C'est l'inverse qu'il faut faire :

Code :

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

1
2
3
4
5
6
7
if f(C) * f(B) < 0:
    # C et B ont des images par f de signes opposés
    # C est "du côté" de A (par rapport à la valeur alpha)
    # c'est A qu'il faut changer, pas B !
    A = C
else:
    B = C

Ensuite, pour être complet, il faudrait peut-être traiter le cas où, après calcul, C se retrouve être la valeur alpha. Dans l'état actuel, on continue à chercher par dichotomie

(dans le bout de code que j'ai écrit, si je cherche K en lui affectant, en dur (f(5) - mileu de 4 et 6, la recherche s'arrête à la seconde itération. Si on ne traite pas ce cas particulier, il en faut plus de 30 à epislon 1e-10 pour obtenir une valeur ... fausse car on se met hors des hypothèses d'une recherche dichotomique : tous les points se retrouvent du même côté par rapport à alpha à un moment donnée)

Les sorties de mon code, pour la recherche de la solution f(x) = 3.5 = f(5) quand on ne s'occupe pas de ces cas particuliers :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
plx@sony:~$ python3 dicho.py 
recherche de f(x) = f(5) = 3.5
iteration  1 : (A,f(A)) = (+4.000,+6.200)  (C,f(C)) = (+5.000,+3.500)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  2 : (A,f(A)) = (+5.000,+3.500)  (C,f(C)) = (+5.500,+0.725)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  3 : (A,f(A)) = (+5.500,+0.725)  (C,f(C)) = (+5.750,-1.084)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  4 : (A,f(A)) = (+5.750,-1.084)  (C,f(C)) = (+5.875,-2.103)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  5 : (A,f(A)) = (+5.875,-2.103)  (C,f(C)) = (+5.938,-2.641)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  6 : (A,f(A)) = (+5.938,-2.641)  (C,f(C)) = (+5.969,-2.918)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  7 : (A,f(A)) = (+5.969,-2.918)  (C,f(C)) = (+5.984,-3.058)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  8 : (A,f(A)) = (+5.984,-3.058)  (C,f(C)) = (+5.992,-3.129)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration  9 : (A,f(A)) = (+5.992,-3.129)  (C,f(C)) = (+5.996,-3.164)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 10 : (A,f(A)) = (+5.996,-3.164)  (C,f(C)) = (+5.998,-3.182)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 11 : (A,f(A)) = (+5.998,-3.182)  (C,f(C)) = (+5.999,-3.191)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 12 : (A,f(A)) = (+5.999,-3.191)  (C,f(C)) = (+6.000,-3.196)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 13 : (A,f(A)) = (+6.000,-3.196)  (C,f(C)) = (+6.000,-3.198)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 14 : (A,f(A)) = (+6.000,-3.198)  (C,f(C)) = (+6.000,-3.199)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 15 : (A,f(A)) = (+6.000,-3.199)  (C,f(C)) = (+6.000,-3.199)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 16 : (A,f(A)) = (+6.000,-3.199)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 17 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 18 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 19 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 20 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 21 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 22 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 23 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 24 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 25 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 26 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 27 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 28 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 29 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 30 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 31 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 32 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 33 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
iteration 34 : (A,f(A)) = (+6.000,-3.200)  (C,f(C)) = (+6.000,-3.200)  (B,f(B)) = (+6.000,-3.200) : f(C) x f(A) > 0 => A devient C
racine 5.999999999941792 trouvée en 34 iterations

1. itération 1 : la valeur C devient la racine. C vaut 5, f(C) vaut 3.5. Pas de traitement particulier, on continue la dichotomie : A devient C et on continue
   
   
2. itération 2 : on s'occupe du milieu de [A;B], etc ...
   
   
3. itérations suivantes : tous les points A, B et C sont strictement supérieurs à la sotuion
   
   
4. on ne fait plus que découper l'intervalle en 2 jusqu'à ce qu'il soit plus petit que la précision mais on est parti dans les choux

[Sve@r]

Ma solution

Recherche f(x)=0.000000 avec bornes entre 4.000000 et 6.000000 (précision=0.000010)
i=1 - (min=4.000000, f=6.200000), (moy=5.000000, f=3.500000), (max=6.000000, f=-3.200000)
i=2 - (min=5.000000, f=3.500000), (moy=5.500000, f=0.725000), (max=6.000000, f=-3.200000)
i=3 - (min=5.500000, f=0.725000), (moy=5.750000, f=-1.084375), (max=6.000000, f=-3.200000)
i=4 - (min=5.500000, f=0.725000), (moy=5.625000, f=-0.142578), (max=5.750000, f=-1.084375)
i=5 - (min=5.500000, f=0.725000), (moy=5.562500, f=0.300342), (max=5.625000, f=-0.142578)
i=6 - (min=5.562500, f=0.300342), (moy=5.593750, f=0.081183), (max=5.625000, f=-0.142578)
i=7 - (min=5.593750, f=0.081183), (moy=5.609375, f=-0.030120), (max=5.625000, f=-0.142578)
i=8 - (min=5.593750, f=0.081183), (moy=5.601562, f=0.025675), (max=5.609375, f=-0.030120)
i=9 - (min=5.601562, f=0.025675), (moy=5.605469, f=-0.002186), (max=5.609375, f=-0.030120)
i=10 - (min=5.601562, f=0.025675), (moy=5.603516, f=0.011754), (max=5.605469, f=-0.002186)
i=11 - (min=5.603516, f=0.011754), (moy=5.604492, f=0.004786), (max=5.605469, f=-0.002186)
i=12 - (min=5.604492, f=0.004786), (moy=5.604980, f=0.001300), (max=5.605469, f=-0.002186)
i=13 - (min=5.604980, f=0.001300), (moy=5.605225, f=-0.000443), (max=5.605469, f=-0.002186)
i=14 - (min=5.604980, f=0.001300), (moy=5.605103, f=0.000429), (max=5.605225, f=-0.000443)
i=15 - (min=5.605103, f=0.000429), (moy=5.605164, f=-0.000007), (max=5.605225, f=-0.000443)
i=16 - (min=5.605103, f=0.000429), (moy=5.605133, f=0.000211), (max=5.605164, f=-0.000007)
i=17 - (min=5.605133, f=0.000211), (moy=5.605148, f=0.000102), (max=5.605164, f=-0.000007)
i=18 - (min=5.605148, f=0.000102), (moy=5.605156, f=0.000048), (max=5.605164, f=-0.000007)
x=5.605156, f(5.605156)=0.000048
moi@debian:~$

En prenant aussi en compte le fait qu'on pouvait tomber sur la solution direct

moi@debian:~$ ./dicho.py
Recherche f(x)=3.500000 avec bornes entre 4.000000 et 6.000000 (précision=0.000010)
i=1 - (min=4.000000, f=6.200000), (moy=5.000000, f=3.500000), (max=6.000000, f=-3.200000)
x=5.000000, f(5.000000)=3.500000
moi@debian:~$

[plxpy]

Salut Sve@r,

je ne trouve pas pareil. J'ai pris N à 1e-10. Toi aussi ?

[EDIT] tu as donné la précision après que j'ai posé la question

Pourquoi ça s'arrête à l'iteration 18 ?
min vaut 5.605148 et max vaut 5.605164. Même avec des "erreurs" d'arrondis/d'affichage, l'intervalle est bien plus grand que 2 * 1e-10. Ca devrait continuer.

Avec N = 1e-10

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
plx@sony:~$ python3 dicho.py 
iteration  1 : (A,f(A)) = (+4.000000e+00,+6.200000e+00)  (C,f(C)) = (+5.000000e+00,+3.500000e+00)  (B,f(B)) = (+6.000000e+00,-3.200000e+00) : f(C) x f(A) > 0 => A devient C
iteration  2 : (A,f(A)) = (+5.000000e+00,+3.500000e+00)  (C,f(C)) = (+5.500000e+00,+7.250000e-01)  (B,f(B)) = (+6.000000e+00,-3.200000e+00) : f(C) x f(A) > 0 => A devient C
iteration  3 : (A,f(A)) = (+5.500000e+00,+7.250000e-01)  (C,f(C)) = (+5.750000e+00,-1.084375e+00)  (B,f(B)) = (+6.000000e+00,-3.200000e+00) : f(C) x f(A) < 0 => B devient C
iteration  4 : (A,f(A)) = (+5.500000e+00,+7.250000e-01)  (C,f(C)) = (+5.625000e+00,-1.425781e-01)  (B,f(B)) = (+5.750000e+00,-1.084375e+00) : f(C) x f(A) < 0 => B devient C
iteration  5 : (A,f(A)) = (+5.500000e+00,+7.250000e-01)  (C,f(C)) = (+5.562500e+00,+3.003418e-01)  (B,f(B)) = (+5.625000e+00,-1.425781e-01) : f(C) x f(A) > 0 => A devient C
iteration  6 : (A,f(A)) = (+5.562500e+00,+3.003418e-01)  (C,f(C)) = (+5.593750e+00,+8.118286e-02)  (B,f(B)) = (+5.625000e+00,-1.425781e-01) : f(C) x f(A) > 0 => A devient C
iteration  7 : (A,f(A)) = (+5.593750e+00,+8.118286e-02)  (C,f(C)) = (+5.609375e+00,-3.012009e-02)  (B,f(B)) = (+5.625000e+00,-1.425781e-01) : f(C) x f(A) < 0 => B devient C
iteration  8 : (A,f(A)) = (+5.593750e+00,+8.118286e-02)  (C,f(C)) = (+5.601562e+00,+2.567549e-02)  (B,f(B)) = (+5.609375e+00,-3.012009e-02) : f(C) x f(A) > 0 => A devient C
iteration  9 : (A,f(A)) = (+5.601562e+00,+2.567549e-02)  (C,f(C)) = (+5.605469e+00,-2.186239e-03)  (B,f(B)) = (+5.609375e+00,-3.012009e-02) : f(C) x f(A) < 0 => B devient C
iteration 10 : (A,f(A)) = (+5.601562e+00,+2.567549e-02)  (C,f(C)) = (+5.603516e+00,+1.175364e-02)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) > 0 => A devient C
iteration 11 : (A,f(A)) = (+5.603516e+00,+1.175364e-02)  (C,f(C)) = (+5.604492e+00,+4.785951e-03)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) > 0 => A devient C
iteration 12 : (A,f(A)) = (+5.604492e+00,+4.785951e-03)  (C,f(C)) = (+5.604980e+00,+1.300420e-03)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) > 0 => A devient C
iteration 13 : (A,f(A)) = (+5.604980e+00,+1.300420e-03)  (C,f(C)) = (+5.605225e+00,-4.427687e-04)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) < 0 => B devient C
iteration 14 : (A,f(A)) = (+5.604980e+00,+1.300420e-03)  (C,f(C)) = (+5.605103e+00,+4.288607e-04)  (B,f(B)) = (+5.605225e+00,-4.427687e-04) : f(C) x f(A) > 0 => A devient C
iteration 15 : (A,f(A)) = (+5.605103e+00,+4.288607e-04)  (C,f(C)) = (+5.605164e+00,-6.945172e-06)  (B,f(B)) = (+5.605225e+00,-4.427687e-04) : f(C) x f(A) < 0 => B devient C
iteration 16 : (A,f(A)) = (+5.605103e+00,+4.288607e-04)  (C,f(C)) = (+5.605133e+00,+2.109600e-04)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
iteration 17 : (A,f(A)) = (+5.605133e+00,+2.109600e-04)  (C,f(C)) = (+5.605148e+00,+1.020080e-04)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
iteration 18 : (A,f(A)) = (+5.605148e+00,+1.020080e-04)  (C,f(C)) = (+5.605156e+00,+4.753153e-05)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
iteration 19 : (A,f(A)) = (+5.605156e+00,+4.753153e-05)  (C,f(C)) = (+5.605160e+00,+2.029321e-05)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
iteration 20 : (A,f(A)) = (+5.605160e+00,+2.029321e-05)  (C,f(C)) = (+5.605162e+00,+6.674028e-06)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
iteration 21 : (A,f(A)) = (+5.605162e+00,+6.674028e-06)  (C,f(C)) = (+5.605163e+00,-1.355698e-07)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) < 0 => B devient C
iteration 22 : (A,f(A)) = (+5.605162e+00,+6.674028e-06)  (C,f(C)) = (+5.605162e+00,+3.269230e-06)  (B,f(B)) = (+5.605163e+00,-1.355698e-07) : f(C) x f(A) > 0 => A devient C
iteration 23 : (A,f(A)) = (+5.605162e+00,+3.269230e-06)  (C,f(C)) = (+5.605162e+00,+1.566830e-06)  (B,f(B)) = (+5.605163e+00,-1.355698e-07) : f(C) x f(A) > 0 => A devient C
iteration 24 : (A,f(A)) = (+5.605162e+00,+1.566830e-06)  (C,f(C)) = (+5.605163e+00,+7.156302e-07)  (B,f(B)) = (+5.605163e+00,-1.355698e-07) : f(C) x f(A) > 0 => A devient C
iteration 25 : (A,f(A)) = (+5.605163e+00,+7.156302e-07)  (C,f(C)) = (+5.605163e+00,+2.900302e-07)  (B,f(B)) = (+5.605163e+00,-1.355698e-07) : f(C) x f(A) > 0 => A devient C
iteration 26 : (A,f(A)) = (+5.605163e+00,+2.900302e-07)  (C,f(C)) = (+5.605163e+00,+7.723023e-08)  (B,f(B)) = (+5.605163e+00,-1.355698e-07) : f(C) x f(A) > 0 => A devient C
iteration 27 : (A,f(A)) = (+5.605163e+00,+7.723023e-08)  (C,f(C)) = (+5.605163e+00,-2.916978e-08)  (B,f(B)) = (+5.605163e+00,-1.355698e-07) : f(C) x f(A) < 0 => B devient C
iteration 28 : (A,f(A)) = (+5.605163e+00,+7.723023e-08)  (C,f(C)) = (+5.605163e+00,+2.403022e-08)  (B,f(B)) = (+5.605163e+00,-2.916978e-08) : f(C) x f(A) > 0 => A devient C
iteration 29 : (A,f(A)) = (+5.605163e+00,+2.403022e-08)  (C,f(C)) = (+5.605163e+00,-2.569777e-09)  (B,f(B)) = (+5.605163e+00,-2.916978e-08) : f(C) x f(A) < 0 => B devient C
iteration 30 : (A,f(A)) = (+5.605163e+00,+2.403022e-08)  (C,f(C)) = (+5.605163e+00,+1.073023e-08)  (B,f(B)) = (+5.605163e+00,-2.569777e-09) : f(C) x f(A) > 0 => A devient C
iteration 31 : (A,f(A)) = (+5.605163e+00,+1.073023e-08)  (C,f(C)) = (+5.605163e+00,+4.080224e-09)  (B,f(B)) = (+5.605163e+00,-2.569777e-09) : f(C) x f(A) > 0 => A devient C
iteration 32 : (A,f(A)) = (+5.605163e+00,+4.080224e-09)  (C,f(C)) = (+5.605163e+00,+7.552146e-10)  (B,f(B)) = (+5.605163e+00,-2.569777e-09) : f(C) x f(A) > 0 => A devient C
iteration 33 : (A,f(A)) = (+5.605163e+00,+7.552146e-10)  (C,f(C)) = (+5.605163e+00,-9.072849e-10)  (B,f(B)) = (+5.605163e+00,-2.569777e-09) : f(C) x f(A) < 0 => B devient C
iteration 34 : (A,f(A)) = (+5.605163e+00,+7.552146e-10)  (C,f(C)) = (+5.605163e+00,-7.602807e-11)  (B,f(B)) = (+5.605163e+00,-9.072849e-10) : f(C) x f(A) < 0 => B devient C
racine 5.6051626015105285 trouvée en 34 iterations f(racine) = 3.395968e-10

Avec N = 1e-5

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
plx@sony:~$ python3 dicho.py 
iteration  1 : (A,f(A)) = (+4.000000e+00,+6.200000e+00)  (C,f(C)) = (+5.000000e+00,+3.500000e+00)  (B,f(B)) = (+6.000000e+00,-3.200000e+00) : f(C) x f(A) > 0 => A devient C
iteration  2 : (A,f(A)) = (+5.000000e+00,+3.500000e+00)  (C,f(C)) = (+5.500000e+00,+7.250000e-01)  (B,f(B)) = (+6.000000e+00,-3.200000e+00) : f(C) x f(A) > 0 => A devient C
iteration  3 : (A,f(A)) = (+5.500000e+00,+7.250000e-01)  (C,f(C)) = (+5.750000e+00,-1.084375e+00)  (B,f(B)) = (+6.000000e+00,-3.200000e+00) : f(C) x f(A) < 0 => B devient C
iteration  4 : (A,f(A)) = (+5.500000e+00,+7.250000e-01)  (C,f(C)) = (+5.625000e+00,-1.425781e-01)  (B,f(B)) = (+5.750000e+00,-1.084375e+00) : f(C) x f(A) < 0 => B devient C
iteration  5 : (A,f(A)) = (+5.500000e+00,+7.250000e-01)  (C,f(C)) = (+5.562500e+00,+3.003418e-01)  (B,f(B)) = (+5.625000e+00,-1.425781e-01) : f(C) x f(A) > 0 => A devient C
iteration  6 : (A,f(A)) = (+5.562500e+00,+3.003418e-01)  (C,f(C)) = (+5.593750e+00,+8.118286e-02)  (B,f(B)) = (+5.625000e+00,-1.425781e-01) : f(C) x f(A) > 0 => A devient C
iteration  7 : (A,f(A)) = (+5.593750e+00,+8.118286e-02)  (C,f(C)) = (+5.609375e+00,-3.012009e-02)  (B,f(B)) = (+5.625000e+00,-1.425781e-01) : f(C) x f(A) < 0 => B devient C
iteration  8 : (A,f(A)) = (+5.593750e+00,+8.118286e-02)  (C,f(C)) = (+5.601562e+00,+2.567549e-02)  (B,f(B)) = (+5.609375e+00,-3.012009e-02) : f(C) x f(A) > 0 => A devient C
iteration  9 : (A,f(A)) = (+5.601562e+00,+2.567549e-02)  (C,f(C)) = (+5.605469e+00,-2.186239e-03)  (B,f(B)) = (+5.609375e+00,-3.012009e-02) : f(C) x f(A) < 0 => B devient C
iteration 10 : (A,f(A)) = (+5.601562e+00,+2.567549e-02)  (C,f(C)) = (+5.603516e+00,+1.175364e-02)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) > 0 => A devient C
iteration 11 : (A,f(A)) = (+5.603516e+00,+1.175364e-02)  (C,f(C)) = (+5.604492e+00,+4.785951e-03)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) > 0 => A devient C
iteration 12 : (A,f(A)) = (+5.604492e+00,+4.785951e-03)  (C,f(C)) = (+5.604980e+00,+1.300420e-03)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) > 0 => A devient C
iteration 13 : (A,f(A)) = (+5.604980e+00,+1.300420e-03)  (C,f(C)) = (+5.605225e+00,-4.427687e-04)  (B,f(B)) = (+5.605469e+00,-2.186239e-03) : f(C) x f(A) < 0 => B devient C
iteration 14 : (A,f(A)) = (+5.604980e+00,+1.300420e-03)  (C,f(C)) = (+5.605103e+00,+4.288607e-04)  (B,f(B)) = (+5.605225e+00,-4.427687e-04) : f(C) x f(A) > 0 => A devient C
iteration 15 : (A,f(A)) = (+5.605103e+00,+4.288607e-04)  (C,f(C)) = (+5.605164e+00,-6.945172e-06)  (B,f(B)) = (+5.605225e+00,-4.427687e-04) : f(C) x f(A) < 0 => B devient C
iteration 16 : (A,f(A)) = (+5.605103e+00,+4.288607e-04)  (C,f(C)) = (+5.605133e+00,+2.109600e-04)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
iteration 17 : (A,f(A)) = (+5.605133e+00,+2.109600e-04)  (C,f(C)) = (+5.605148e+00,+1.020080e-04)  (B,f(B)) = (+5.605164e+00,-6.945172e-06) : f(C) x f(A) > 0 => A devient C
racine 5.605155944824219 trouvée en 17 iterations f(racine) = 4.753153e-05
plx@sony:~$

J'ai une itération de moins. As tu pensé à mettre 2 * N comme taille max de l'intervalle final, et pas seulement N ? On a le droit d'être à moins de N mais de part et d'autres de la valeur théorique.

[Sve@r]

J'ai une itération de moins. As tu pensé à mettre 2 * N comme taille max de l'intervalle final, et pas seulement N ? On a le droit d'être à moins de N mais de part et d'autres de la valeur théorique.

Non j'ai juste mis while (max - min) > 10 ** -precision...