Problème de précision

Invité · 05/03/2018, 20h04

Bonsoir

Un programme pour trouver une puissance (ex), qui exposée étend un nombre (n1) vers un nombre (n2).
Tout est clair lorsque le type integer est actif.

Code :

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

expose = int(nombre**collee) - ult

Mais lors du retrait integer, à un moment il n'y a plus d'évolution, il ne reste qu'une boucle infinie.

Code :

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

expose = (nombre**collee) - ult

Le code avec le type integer, et sa fenêtre résultat

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Puissance ultime
""" Procédé de mise à niveau de l'exposant"""
# Music@toumic
print("""Puissance(ex) Relative:\n Commun(n1) = Nombre(n2)**(ex)
    L'exposant est basique
""")
 
def stage(ult):
    """Part de l'exposant(ex) sur nombre(n2)  
    pour une approche du nombre(n1)
        (ex) = exposant | (n1) = (n2) ** (ex)"""
    # pour(' *M*', ult) 
    memore = {}  # Mémoire ponctuelle
    expose = 0.1  # Différentiel (ult)
    pointe = 0.0  # Zéro et Réel
    exp = [.1]  # Un décimal
    but = 3  # Niveau décimal
    pas = www = 1
    # Exposé décimal
    while expose > 0.0:
        while 1:
            pointe += exp[0]  # Décimale ajoutée
            copiee = str(pointe)  # Image de forme
            collee = float(copiee[:but])  # Forme
            expose = int(nombre**collee) - ult
            # Relative: Nombre - Commun
            if expose < 0.0 and collee not in memore:
                memore[0] = float(copiee[:but])
                print('expose', expose, 'memore', memore)
            else:
                refute[ult] = [collee,nombre**collee]
                break
        if memore:
            # Mises à niveaux
            pointe = memore[0]
            exp[0] /= 10  # Décimale ajoutée
            but += 1  # Mise en forme
        else:
            memore[0] = ult
            break
        www += 1
 
    if memore:
        etagee[ult] = memore[0]
 
etagee = {}
refute = {}
# Appel stage
nivele = [325413]  # nivele
nombre = 23154687  # nombre
print(' nombre = {}\n nivele(n1) = {}'. format(nombre,nivele))
for ni in nivele:
    stage(ni)
# Stage relate
for et, it in etagee.items():
    if it < 1.0:
        print('n1 = {} ; exINF = {} ; n2ex = {}'.
              format(et,it,nombre**it))
    else:
        print('n1 = {} ; exSUP = {} ; n2ex = {}'.
              format(et,it,nombre**it))
    print(' refute = {}'. format(refute[et]))
# Remarques:
"""Le résultat n'est pas justifié
Exemple(n1 = 32541):
    exINF = 0.481858
    nombre = 2315468792
        n2ex = nombre ** exINF
        n1 - n2ex = 0.35279225077465526
        ...
:expose = int(nombre**collee) - ult:
    L':int(): est la cause de l'interruption
    L'enlever, fait la condition anormale
        À résoudre..."""
# f

Résultat avec l'integer

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
38
 
Puissance(ex) Relative:
 Commun(n1) = Nombre(n2)**(ex)
    L'exposant est basique
 nombre = 23154687
 nivele(n1) = [325413]
expose -325408 memore {0: 0.1}
expose -325384 memore {0: 0.2}
expose -325252 memore {0: 0.3}
expose -324531 memore {0: 0.4}
expose -320602 memore {0: 0.5}
expose -299184 memore {0: 0.6}
expose -182443 memore {0: 0.7}
expose -182443 memore {0: 0.7}
expose -156021 memore {0: 0.71}
expose -124717 memore {0: 0.72}
expose -87627 memore {0: 0.73}
expose -43684 memore {0: 0.74}
expose -38865 memore {0: 0.741}
expose -33965 memore {0: 0.742}
expose -28980 memore {0: 0.743}
expose -23911 memore {0: 0.744}
expose -18754 memore {0: 0.745}
expose -13510 memore {0: 0.746}
expose -8175 memore {0: 0.747}
expose -2750 memore {0: 0.748}
expose -2202 memore {0: 0.7481}
expose -1654 memore {0: 0.7482}
expose -1104 memore {0: 0.7483}
expose -554 memore {0: 0.7484}
expose -554 memore {0: 0.7484}
expose -3 memore {0: 0.7485}
expose -2 memore {0: 0.7485001}
expose -1 memore {0: 0.7485002}
expose -1 memore {0: 0.7485002}
expose -1 memore {0: 0.7485003}
n1 = 325413 ; exINF = 0.7485003 ; n2ex = 325412.65408562496
 refute = [0.7485004, 325413.20591136214]

Puis, celle du résultat sans l'effet integer

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
Puissance(ex) Relative:
 Commun(n1) = Nombre(n2)**(ex)
    L'exposant est basique
 nombre = 23154687
 nivele(n1) = [325413]
expose -325407.5491542615 memore {0: 0.1}
expose -325383.28828073456 memore {0: 0.2}
expose -325251.046001657 memore {0: 0.3}
expose -324530.2137382914 memore {0: 0.4}
expose -320601.06826731714 memore {0: 0.5}
expose -299183.9024207229 memore {0: 0.6}
expose -182442.23523404315 memore {0: 0.7}
expose -182442.23523404315 memore {0: 0.7}
expose -156020.71383506389 memore {0: 0.71}
expose -124716.39843145365 memore {0: 0.72}
expose -87626.93079290318 memore {0: 0.73}
expose -43683.19358047936 memore {0: 0.74}
expose -38864.964249566314 memore {0: 0.741}
expose -33964.33208673319 memore {0: 0.742}
expose -28979.88781354134 memore {0: 0.743}
expose -23910.198049641156 memore {0: 0.744}
expose -18753.8049005738 memore {0: 0.745}
expose -13509.225538523518 memore {0: 0.746}
expose -8174.951775899623 memore {0: 0.747}
expose -2749.4496316257864 memore {0: 0.748}
expose -2201.8220175577444 memore {0: 0.7481}
expose -1653.2649647497456 memore {0: 0.7482}
expose -1103.7768957495573 memore {0: 0.7483}
expose -553.3562304278021 memore {0: 0.7484}
expose -553.3562304278021 memore {0: 0.7484}
expose -2.001385972602293 memore {0: 0.7485}
expose -1.4495630427263677 memore {0: 0.7485001}
expose -0.897739177045878 memore {0: 0.7485002}
expose -0.897739177045878 memore {0: 0.7485002}
expose -0.3459143750369549 memore {0: 0.7485003}
expose -0.29073184373555705 memore {0: 0.74850031}
expose -0.2355493024806492 memore {0: 0.74850032}
expose -0.18036675185430795 memore {0: 0.74850033}
expose -0.1251841924386099 memore {0: 0.74850034}
expose -0.07000162312760949 memore {0: 0.74850035}
expose -0.014819045027252287 memore {0: 0.74850036}
expose -0.009300786827225238 memore {0: 0.748500361}
expose -0.009300786827225238 memore {0: 0.748500361}
expose -0.0037825279287062585 memore {0: 0.748500362}
expose -0.003230702015571296 memore {0: 0.7485003621}
expose -0.002678876102436334 memore {0: 0.7485003622}
expose -0.0021270501893013716 memore {0: 0.7485003623}
expose -0.0015752249164506793 memore {0: 0.7485003624}
expose -0.001023399003315717 memore {0: 0.7485003625}
expose -0.0004715731483884156 memore {0: 0.7485003626}
expose -0.00041639053961262107 memore {0: 0.74850036261}
expose -0.00036120793083682656 memore {0: 0.74850036262}
expose -0.00030602538026869297 memore {0: 0.74850036263}
expose -0.00025084277149289846 memore {0: 0.74850036264}
expose -0.00019566016271710396 memore {0: 0.74850036265}
expose -0.00014047761214897037 memore {0: 0.74850036266}
expose -8.529500337317586e-05 memore {0: 0.74850036267}
expose -3.0112394597381353e-05 memore {0: 0.74850036268}
expose -2.459425013512373e-05 memore {0: 0.748500362681}
expose -2.459425013512373e-05 memore {0: 0.748500362681}
expose -1.907552359625697e-05 memore {0: 0.748500362682}
expose -1.3557379133999348e-05 memore {0: 0.748500362683}
expose -8.039234671741724e-06 memore {0: 0.748500362684}
expose -2.5210902094841003e-06 memore {0: 0.748500362685}
expose -1.969106961041689e-06 memore {0: 0.7485003626851}
expose -1.4171237125992775e-06 memore {0: 0.7485003626852}
expose -8.657225407660007e-07 memore {0: 0.7485003626853}
expose -3.137392923235893e-07 memore {0: 0.7485003626854}
expose -2.586166374385357e-07 memore {0: 0.74850036268541}
expose -2.034357748925686e-07 memore {0: 0.74850036268542}
expose -1.4831312000751495e-07 memore {0: 0.74850036268543}
expose -9.319046512246132e-08 memore {0: 0.74850036268544}
expose -3.8067810237407684e-08 memore {0: 0.74850036268545}
expose -3.8067810237407684e-08 memore {0: 0.74850036268545}
expose -3.253808245062828e-08 memore {0: 0.748500362685451}
expose -2.7008354663848877e-08 memore {0: 0.748500362685452}
expose -2.1478626877069473e-08 memore {0: 0.748500362685453}
expose -1.6007106751203537e-08 memore {0: 0.748500362685454}
expose -1.0477378964424133e-08 memore {0: 0.748500362685455}
expose -1.0477378964424133e-08 memore {0: 0.748500362685455}
expose -4.3655745685100555e-09 memore {0: 0.748500362685456}
expose -3.725290298461914e-09 memore {0: 0.7485003626854562}
expose -3.14321368932724e-09 memore {0: 0.7485003626854563}
expose -2.5029294192790985e-09 memore {0: 0.7485003626854564}
expose -1.9208528101444244e-09 memore {0: 0.7485003626854565}
expose -1.280568540096283e-09 memore {0: 0.7485003626854566}
expose -6.984919309616089e-10 memore {0: 0.7485003626854567}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}
expose -5.820766091346741e-11 memore {0: 0.7485003626854568}

Je ne sais pas pourquoi ça bloque ?

**Sve@r** · 05/03/2018, 20h46

Envoyé par toumic

Je ne sais pas pourquoi ça bloque ?

Bonjour

Tu as une fonction qui tend vers N (par valeurs inférieures) sans jamais l'atteindre (puisque cette fonction calcule N ** p avec p < 1 ce qui donne en fait racine_p_ieme de N ce qui reste inférieur strict à N). A ce résultat tu enlèves ce "N" et tu ne sors que si le total (qui est alors inférieur à 0) est supérieur ou égal à 0. Donc tu ne sors pas.

Quand tu castes ton opération en int, tu supprimes les décimales donc tu supprimes de la valeur. Le résultat (qui utilise les valeurs des itérations précédentes) atteint alors N (pourquoi j'en sais rien, il faudrait étudier la fonction plus attentivement mais je pense que tu t'en fouts). Ce qui compte, c'est que quand tu lui ôtes ce N tu obtiens 0 et tu quittes ta boucle.

Envoyé par toumic

Mais lors du retrait integer, à un moment il n'y a plus d'évolution, il ne reste qu'une boucle infinie.

Conclusion erronée. Tu as une fonction qui, telle qu'elle est programmée, ne doit jamais sortir. Ca c'est une erreur de programmation dans ta condition de sortie. Il se trouve qu'en transformant son résultat en integer tu atteints la limite théoriquement inatteignable donc là tu sors et l'erreur est masquée. En supprimant cet integer parasite tu reviens à la fonction d'origine donc celle qui ne sors pas. Bref c'est en mettant l'integer que ton programme a un comportement erratique et non en le supprimant.

Change ta condition de sortie pour que ta fonction, en calculant avec exactitude, sorte quand la limite est atteinte et tu pourras rajouter ou supprimer l'integer sans changer le comportement. Perso je mémoriserais le résultat d'une itération à l'autre et je sortirais quand la différence entre le dernier calcul et l'avant dernier devient inférieure à un epsilon de mon choix.

**lg_53** · 05/03/2018, 21h49

En calcul scientifique lorsqu'on calcul une approximation on ne s'arrête jamais lorsqu'on a une égalité parfaite car cela n'arrive jamais. On ne teste donc pas

Code :

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

1
2
3
while a != b: 
    ...traitement...
return

ni (de manière équivalente)

Code :

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

1
2
3
while b-a != 0:
     ...traitement...
return

mais plutôt, on donne une tolérence eps, que l'on peut faire éventuellement descendre ou monter selon les besoins en précision.

Code :

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

1
2
3
4
eps=1e-5
while abs(b-a)>eps: 
     ...traitement...
return

Souvent même pour éviter de rester stagner dans cette boucle infinie (admettons si on se trouve dans un cas où la convergence est hyper lente), on va ajouter un critère sur le nombre d'itérations maximum à faire (comme ca au moins on est sûr de sortir un jour)

Code :

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

1
2
3
4
5
6
eps=1e-5
max_iter=int(1e5)
while abs(b-a)>eps and n_iter<max_iter :
        ...traitement...
        n_iter+=1
return

PS : Ici a et b peuvent désigner :
- deux itérés consécutifs
- ou bien l'un la valeur de l'itération en cours, l'autre une valeur exacte connue

Invité · 06/03/2018, 19h51

Au début je pensais que c'était dû à un défaut de précision, à cause du blocage. J'ai pensé à utiliser le module decimal, mais si je peux m'en passer...
Le tout pour moi n'est pas de digérer ce qui a déjà été mâché, mais je plaisanterais en disant que vos chewing gums sont réguliers. Cette boucle interminable a trouvé sa solution, vous pouvez le voir dans le code "BIEN", "STOP". Il reste le problème de la justesse, car à en croire l'issue il y en a encore d'autres, ce n'est pas fini. Tant que je n'en connais pas la fin

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Puissance ultime
""" Procédé de mise à niveau de l'exposant"""
# Music@toumic
print("""Puissance(ex) Relative:\n Commun(n1) = Nombre(n2)**(ex)
    L'exposant est basique
""")
def stage(ult):
    """Part de l'exposant(ex) sur nombre(n2)  
    pour une approche du nombre(n1)
        (ex) = exposant | (n1) = (n2) ** (ex)"""
    # pour(' *M*', ult)
    imagee = {}  # Détecte l'interminable
    imagee[2] = "BIEN"
    memore = {}  # Mémoire ponctuelle
    expose = 0.1  # Différentiel (ult)
    pointe = 0.0  # Zéro et Réel
    exp = [.1]  # Un décimal
    but = 3  # Niveau décimal
    www = 0
    # Exposé décimal
    while imagee[2] == "BIEN":
        www += 1
        pas = ima = 0
        while 1:
            pointe += exp[0]  # Décimale ajoutée
            copiee = str(pointe)  # Image de forme
            collee = float(copiee[:but])  # Forme
            if ima == 0:
                imagee[1] = collee, pas
                ima = 1
            expose = (nombre**collee) - ult
            # Relative: Nombre - Commun
            if expose < 0.0 and imagee[2] == "BIEN":
                memore[0] = collee
                pas += 1
                if pas > 10 and imagee[1][0] == memore[0]:
                    imagee[2] = "STOP"
            else:
                refute[ult] = [collee,nombre**collee]
                break
 
        if memore:
            # Mises à niveaux
            pointe = memore[0]
            exp[0] /= 10  # Décimale ajoutée
            but += 1  # Mise en forme
        else:
            memore[0] = ult
            break
 
    if memore:
        etagee[ult] = memore[0]
 
etagee = {}
refute = {}
# Appel stage 23154687 325413.20591136214
nivele = [325413]  # nivele
nombre = 23154687  # nombre
print(' nombre = {}\n nivele(n1) = {}'. format(nombre,nivele))
for ni in nivele:
    stage(ni)
# Stage relate
for et, it in etagee.items():
    if it < 1.0:
        print('n1 = {} ; exINF = {} ; n2ex = {}'.
              format(et,it,nombre**it))
    else:
        print('n1 = {} ; exSUP = {} ; n2ex = {}'.
              format(et,it,nombre**it))
    print(' refute = {}'. format(refute[et]))
# Remarques:
"""Le résultat n'est pas justifié
Exemple(n1 = 32541):
    exINF = 0.481858
    nombre = 2315468792
        n2ex = nombre ** exINF
        n1 - n2ex = 0.35279225077465526
        ...
:expose = int(nombre**collee) - ult:
    L':int(): est la cause de l'interruption
    L'enlever, fait la condition anormale
        À résoudre..."""
# f

**Sve@r** · 06/03/2018, 20h45

Mouais. On peut pas dire que ce code soit représentatif de l'élégance. Utiliser "BIEN" et "STOP" (des chaines) alors qu'il existe True et False (des booléens où la comparaison sera bien plus rapide), un tableau" exp" ne contenant qu'un seul élément, un dictionnaire "memore" ne contenant lui-aussi qu'un seul élément, combiner des éléments aussi disparates qu'un tuple de calcul et un flag de fin dans un même item "imagee"... bref.

Mais au-moins ton code fonctionne et c'est le principal. Pour le reste tu apprendras...

Invité · 07/03/2018, 20h22

Envoyé par Sve@r

Mouais. On peut pas dire que ce code soit représentatif de l'élégance. Utiliser "BIEN" et "STOP" (des chaines) alors qu'il existe True et False (des booléens où la comparaison sera bien plus rapide), un tableau" exp" ne contenant qu'un seul élément, un dictionnaire "memore" ne contenant lui-aussi qu'un seul élément, combiner des éléments aussi disparates qu'un tuple de calcul et un flag de fin dans un même item "imagee"... bref.

Mais au-moins ton code fonctionne et c'est le principal. Pour le reste tu apprendras...

Première leçon de courtoisie
Pour un nombre =

25648

Pour sa racine² =

160.1499297533408

Code :

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

1
2
3
4
5
6
 
>>> 25648**.5
160.1499297533408
>>> 160.1499297533408**2
25647.999999999996
>>>

Normalement | nombre**.5 = (nombre**.5)**2 ?

Problème de précision [Python 3.X]

Python

Vue hybride

Discussions similaires

Partager

Partager