arrêter l'itération d'une fonction racine

bonjour,
comment arrêter l'itération quand la valeur de r est suffisamment proche de la valeur exacte de la racine recherchée.

étant donné le programme:
début
r = 1
répéter
r =(r + n / r) / 2
fin
le coder convenablement en PYTHON et le faire tourner"; limiter les répétitions";

ce que j'ai pu faire
mais je trouve pas comment arretter l'itération ?!!

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

def racine(n) : r = 1 for x in range(10): r = (r + (n/r))/ 2 return r   >>> racine(25.0) 5.0 >>> racine(2.0) 1.414213562373095 >>> racine(28.0) 5.291502622129181 >>> racine(144.0) 12.0

---

merci

Salut,

Je ne sait pas si c'est précisément ce que tu cherches, mais en Python, dans les boucles FOR et WHILE, tu peut utiliser le mot clé BREAK afin d'interrompre la boucle (voir ICI)

Bonjour,

Pour compléter Deusyss, la function "racine" devrait prendre selon moi trois paramètres:

• la valeur dont on veut la racine
• le nombre max d'itérations
• la tolérance

La tolérance, par exemple tol, te permet de definir à partir de quand stopper le calcul. Si abs(val(k)-val(k-1)) < tol (soit si la valeur actuelle de la racine moins celle trouvée pendant la précédente boucle est inférieur à une certaine tolerance) on stop le calcul meme si on a pas atteint le nombre max d'itérations. Avec break comme l'a dit Deusyss par exemple.

Tu as à donc definir 2 conditions pour stopper le calul. Je partirais sur une boucle while pour ma part.


J

non je pense pas car dans le cours le prof a dit :
Il serait sans doute souhaitable que le programme s’arrête au bout d’un certain temps, par exemple après avoir répété un certain nombre de fois les calculs, ou bien quand la valeur de r est suffisamment proche de la valeur exacte de la racine recherchée. (On peut évaluer facilement cette erreur ; plus n - r2 se rapproche de 0 et plus l’erreur est petite.)

:s

Citation:

---

Envoyé par Julien N

Bonjour,

Pour compléter Deusyss, la function "racine" devrait prendre selon moi trois paramètres:

• la valeur dont on veut la racine
• le nombre max d'itérations
• la tolérance

La tolérance, par exemple tol, te permet de definir à partir de quand stopper le calcul. Si abs(val(k)-val(k-1)) < tol (soit si la valeur actuelle de la racine moins celle trouvée pendant la précédente boucle est inférieur à une certaine tolerance) on stop le calcul meme si on a pas atteint le nombre max d'itérations. Avec break comme l'a dit Deusyss par exemple.

Tu as à donc definir 2 conditions pour stopper le calul. Je partirais sur une boucle while pour ma part.


J

---

*abs(val(k)-val(k-1)) < tol je n'es pas compris ??!!! tant que la racine carré est proche de la valeur en stop mais comment l'écrire sa !!!

def racine(n) :
r = 1
for x in range(10):
r = (r + (n/r))/ 2
while (n - r ** 2) = 0
break
return r

je vois pas comment écrire que si n - r ** 2 est égal presque a 0 !!! car la veut dire que l'erreur est petite

On est pas non plus oblige de respecter à la letter ce que le prof a dit...

Mais bon, si tu écris while (n - r ** 2) = 0, tu devrais pouvoir écrire while abs(n - r ** 2) > tol. Le truc, c'est qu'on cherche ici une valeur approchée, pas exacte. On ne cherche pas à savoir si l'erreur est nulle, mais plutôt à savoir si l'erreur est plus faible qu'une certaine tolerance. Autrement dit, est-ce suffisament juste?

Je mets une valeur absolue, par ce que la difference peut être negative.

Ju

mais tol veut dire tolerance !! et est ce qu'on j'ai le doit de le mettre comme sa dans le code

Code:

---

1 2 3 4 5 6 7

def racine(n) : r = 1 for x in range(10): r = (r + (n/r))/ 2 while abs(n - r ** 2) > tol break return r

---

La tolérance dont parle Julien est une valeur de comparaison.

Communément appelée "epsilon" [1], elle sert à comparer des float en limitant la comparaison à un nombre de décimales raisonnable.
Afin d'éviter ceci

Code:

---

1 2 3 4

>>> 0.2 == 1.2 - 1.0 False >>>

---

On définit une valeur epsilon qui représente la précision maximale qui nous intéresse:

Code:

---

1 2	>>> epsilon = 0.00001

---

et puis on compare

Code:

---

1 2 3

>>> 0.2 - (1.2 - 1.0) < epsilon True

---

Pour info:

Code:

---

1 2 3 4

>>> import sys >>> sys.float_info.epsilon 2.220446049250313e-16

---

[1] http://docs.python.org/2/faq/design....-so-inaccurate

daccord donc pour cette exo faut que quand n-r**2 > epsilon l'itération s'arrette c'es ca !!

Code:

---

1 2 3 4 5 6 7 8

def racine(n,epsilon) : epsilon = 0.0000000000001 r = 1 for x in range(10): r = (r + (n/r))/ 2 while abs(n - r ** 2) > epsilon : break return r

---

Non, ce n'est pas "while" mais "if"

Non, ce n'est pas ">" mais "<"

Tu les testes tes codes ?

bjrs

je viens de le tester c'est faus ce que j pas compris c'est cette ligne

Code:

---

1 2 3

if abs(n - r ** 2) > epsilon : break return r

---

merci pour les réponses

par contre sa marche bien avec

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def racine(n,epsilon) : epsilon = 0.0000000000001 r = 1 for x in range(10): r = (r + (n/r))/ 2 if abs(n - r ** 2) < epsilon : break return r >>> racine(25.0) 5.0 >>> racine(2.0) 1.414213562373095 >>> racine(28.0) 5.291502622129181 >>> racine(144.0) 12.0

---

Salut,

C'est bien mieux maintenant mais il y a encore deux petites choses à améliorer:

1. Tu passes epsilon en paramètre, c'est bien, mais il ne faut pas lui donner une valeur par défaut dans la fonction mais directement dans sa "déclaration"
2. Tu ne laisse pas le choix à l'utilisateur du nombre max d'itération, chez toi 10

Voici une autre version:

Code:

---

1 2 3 4 5 6 7 8 9 10

def racine(n, maxiter=10, epsilon=1e-6) : r = 1 for x in range(maxiter): r = (r + (n/r))/ 2 if abs(n - r ** 2) < epsilon : break return r   print racine(2.0) >>>1.414213562373095

---

Maintenant tu dois savoir qu'une racine carrée n'est possible que pour un nombre strictement positif. Il faudrait rajouter un test en début de ta fonction pour vérifier la validité de l'entrée.

Exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

def racine(n, maxiter=10, epsilon=1e-6) : try: n = float(n) except: print 'Racine() accepte uniquement un nombre' return None assert n > 0 r = 1 for x in range(maxiter): r = (r + (n/r))/ 2 if abs(n - r ** 2) < epsilon : break return r

---

Bon on peut faire mieux, plus concis comme gestion d'erreur. Je veux juste te montrer que cela existe et que tu pourrais en tenir compte.

Ju

Citation:

---

Envoyé par Julien N

La tolérance, par exemple tol, te permet de definir à partir de quand stopper le calcul. Si abs(val(k)-val(k-1)) < tol (soit si la valeur actuelle de la racine moins celle trouvée pendant la précédente boucle est inférieur à une certaine tolerance) on stop le calcul meme si on a pas atteint le nombre max d'itérations.

---

Bonjour

Pour ce genre de problème (limite d'une suite), il y a encore mieux que de choisir une tolérance arbitraire: laisser le processeur lui-même trouver sa propre tolérance. En effet, s'il arrive à une précision telle qu'il ne puisse plus faire la différence entre l'itération et l'itération précédente, alors la tolérance est atteinte et il peut s'arrêter et renvoyer la valeur

Typiquement

Code:

---

1 2 3 4 5 6 7 8 9

def racine(n): r=1.0 tol=0 while r != tol: tol=r r=(r+n/r) / 2.0 # Celui qui connait les priorités des opérateurs mathématiques (CE1) peut éviter les parenthèses inutiles... # while return r # racine()

---

Au moment où il n'arrive plus à faire la différence entre tol (valeur précédente) et r (valeur actuelle), on a trouvé la précision maximale de la racine demandée....

Bonjour à tous,

je vois qu'en une journée le sujet à bien avancé. C'est super.

Je rejoint Julien N sur le fait qu'il vaut mieux prevoir de pouvoir passer un maximum de paramètre à la fonction, et de leur définir des valeurs par défaut. Ainsi en cas d'evolution de ton besoin , tu ne sera pas forcement obligé de retouché le code de ta fonction, mais uniquement ses appels.

Sve@r, concernant ta solution, ne serait-il pas possible de passer par un formatage des nombres afin de choisir la précision désirée? Par exemple avec un

Code:

---

1 2 3 4 5 6 7 8

while t0 != t1: tol=r r=(r+n/r) / 2.0 t0 = "%." + str(precision) + "f" t0 = t0%r   t1 = "%." + str(precision) + "f" t1 = t1%tol

---

avec précision étant le nombre de chiffre désirés après la virgule. Ainsi on combine ton idée de laisser le pross trouver lui meme sa limite, et en meme temps l'utilisateur à un la possibilité, lors de l'appel de al fonction d'indiquer la precision souhaitée.

Votre avis?

Citation:

---

Envoyé par deusyss

Sve@r, concernant ta solution, ne serait-il pas possible de passer par un formatage des nombres afin de choisir la précision désirée?

---

Tout est toujours possible. Je voulais juste montrer qu'on a possibilité ne pas (si on le désire) se casser la tête à choisir un epsilon et laisser la machine le trouver pour nous...

Citation:

---

Envoyé par Julien N

Salut,

C'est bien mieux maintenant mais il y a encore deux petites choses à améliorer:

1. Tu passes epsilon en paramètre, c'est bien, mais il ne faut pas lui donner une valeur par défaut dans la fonction mais directement dans sa "déclaration"
2. Tu ne laisse pas le choix à l'utilisateur du nombre max d'itération, chez toi 10

Voici une autre version:

Code:

---

1 2 3 4 5 6 7 8 9 10

def racine(n, maxiter=10, epsilon=1e-6) : r = 1 for x in range(maxiter): r = (r + (n/r))/ 2 if abs(n - r ** 2) < epsilon : break return r   print racine(2.0) >>>1.414213562373095

---

Maintenant tu dois savoir qu'une racine carrée n'est possible que pour un nombre strictement positif. Il faudrait rajouter un test en début de ta fonction pour vérifier la validité de l'entrée.

Exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

def racine(n, maxiter=10, epsilon=1e-6) : try: n = float(n) except: print 'Racine() accepte uniquement un nombre' return None assert n > 0 r = 1 for x in range(maxiter): r = (r + (n/r))/ 2 if abs(n - r ** 2) < epsilon : break return r

---

Bon on peut faire mieux, plus concis comme gestion d'erreur. Je veux juste te montrer que cela existe et que tu pourrais en tenir compte.

Ju

---

merci bcp julien sa l'aire très claire :)

merci pour les réponses j'ai bien appris :)

Salut,

Si tu penses que tu as obtenu toutes les reponses à tes questions, merci de marquer le sujet comme resolu (bouton en bas de la discussion).

Merci