Discussion :

[l1informatique]

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 :

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

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

[deusyss]

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)

[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

[l1informatique]

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

[l1informatique]

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 !!!

[l1informatique]

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

[Julien N]

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

[l1informatique]

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

Code :

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

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

[VinsS]

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 :

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

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 :

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

1
2
 
>>> epsilon = 0.00001

et puis on compare

Code :

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

1
2
3
 
>>> 0.2 - (1.2 - 1.0) < epsilon
True

Pour info:

Code :

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

1
2
3
4
 
>>> import sys
>>> sys.float_info.epsilon
2.220446049250313e-16

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

[l1informatique]

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

Code :

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

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

[VinsS]

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

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

Tu les testes tes codes ?

[l1informatique]

bjrs

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

Code :

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

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

merci pour les réponses

[l1informatique]

par contre sa marche bien avec

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
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

[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 :

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

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 :

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

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

[Sve@r]

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 python :

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

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....

[deusyss]

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 :

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

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?

[Sve@r]

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...

[l1informatique]

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 :

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

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 :

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

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

[l1informatique]

merci pour les réponses j'ai bien appris

[deusyss]

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