Problème de précision

Version imprimable

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:

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:

expose = (nombre**collee) - ult

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

Code:

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:

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:

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 ?

05/03/2018, 20h46
Sve@r

Citation:

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.

Citation:

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.
05/03/2018, 21h49
lg_53
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:

1 2 3 while a != b: ...traitement... return
ni (de manière équivalente)
Code:

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:

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:

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

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:

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

06/03/2018, 20h45
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...;)
07/03/2018, 20h22
Invité
Citation:

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:

1 2 3 4 5 6 >>> 25648**.5 160.1499297533408 >>> 160.1499297533408**2 25647.999999999996 >>>
Normalement | nombre**.5 = (nombre**.5)**2 ?

ET si

Code:

1
2
3
4
5
 
                # Zéro égal expose
                if expose == 0.0:
                    memore[0] = collee
                    imagee[2] = "STOP"

Faisait partie d'une solution ?

07/03/2018, 20h53
wiztricks
Citation:
Envoyé par toumic

Première leçon de courtoisie
Pour un nombre =
25648
Pour sa racine² =
160.1499297533408

Code:

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

Normalement | nombre**.5 = (nombre**.5)**2 ?
La représentation des nombres flottants en binaire joue toujours des tours.
Mais depuis le temps, nous avons de bons tutos qui expliquent bien tout çà.

- W
07/03/2018, 21h43
Sve@r

Citation:

Envoyé par toumic

Première leçon de courtoisie
Pour un nombre =
25648
Pour sa racine² =
160.1499297533408

Première leçon de mathématiques
160.1499297533408 n'est pas la racine carrée de 25648. Ce n'est qu'une valeur approchée. Et ça, même Pythagore s'en était rendu compte (même s'il n'a jamais su en comprendre la raison).
Donc il est tout à fait naturel que 160.1499297533408 élevé au carré ne donne pas 25648.

puissance négative où es-tu ?

Merci pour vos orientations (tuto y compris), après le problème du fait que l'élément zéro n'était pas testé.

Code:

if expose.real == 0.0:

Le code fonctionne avec les nombres réels positifs, et lorsque le nombre est négatif, l'opération portée sur :expose: faisait que son type était complex. Et qu'un moyen de lire du complexe, est bien d'ajouter un .real. Ce dernier a fait fonctionner ce programme, mais il y a que si l'élément de :nivele: est négatif ça crée un problème qui reste à résoudre...

Code:

1
2
3
 nOmbre = 231546 ; typO = 0
 nIvele = -546 ; typI = 0
exINF = -546 ; n2ex = 0.0

Je m'en tiendrais là, en ce qui concerne ce message, à moins de quelques réponses

Voici légèrement fini le code puissant :)

Code:

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Puissance ultime
""" Procédé de mise à niveau de l'exposant"""
# Music@toumic:     puissance6relative.py
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 = {2: "BIEN"}  # Détecte l'interminable
    memore = {}  # Mémoire ponctuelle
    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
            puisse = (nombre ** collee).real
            expose = puisse - ult
            #print('collee=',collee,';ult=',ult)
            #print('puisse=',puisse,';ult=',ult)
            if ima == 0:
                imagee[1] = collee
                imagee[3] = expose
                ima = 1
                print('WIexpose', expose, puisse, 'pas', pas)
            # Nombre négatif = complex(puissance)
            if expose < 0.0 and imagee[2] == "BIEN":
                memore[0] = collee
                pas += 1
                if pas > 10:
                    if imagee[1] == memore[0] \
                            or imagee[3] == expose:
                        imagee[2] = "STOP"
                        print('IIimagee', imagee, pas)
            else:
                refute[ult] = [collee, puisse]
                # Zéro égal expose
                if expose == 0.0:
                    memore[0] = collee
                    imagee[2] = "STOP"
                    print('EIimagee', imagee, pas)
                break
        if memore:
            # Mises à niveaux
            pointe = memore[0]
            exp[0] /= 10  # Décimale ajoutée
            but += 1  # Mise en forme
        else:
            memore[0] = ult
            print('IEmemore', ult, 'pas', pas)
            break
    if memore:
        etagee[ult] = memore[0]
 
etagee = {}
refute = {}
# Appel stage
nivele = [54]  # nivele problème négatif
nombre = -230000001546  # nombres impuissants (0,1]
print(' nOmbre = {} ; typO = {}\n nIvele = {} ; typI = {}'.
      format(nombre, nombre % 6, nivele[0], nivele[0] % 6))
for ni in nivele:
    if ni > 0:  # Solution provisoire
        stage(ni)
# Stage relate
for et, it in etagee.items():
    if it < 1.0:
        print('exINF = {} ; n2ex = {}'.format(it, (nombre ** it).real))
    else:
        print('eXSUP = {} ; n2ex = {}'.format(it, (nombre ** it).real))
    # print(' refute = {}'. format(refute[et]))
# Remarques:
"""Le résultat n'est pas justifié
Exemple(n1 = 32541):
    exINF = 0.4818585027866879
    nombre = 2315468792
        n2ex = nombre ** exINF
        n1 - n2ex = 7.639755494892597e-11
        ..."""
# Stage négatif
"""Nombre négatif accepté
    Nombre nivele refusé, en cours
Nombre négatif: OUI
     nOmbre = -231546 ; typO = 0
     nIvele = 546 ; typI = 0
    eXSUP = 1.500001559834342 ; n2ex = 545.9999998981401
Nivele négatif: NON
     nOmbre = 231546 ; typO = 0
     nIvele = -546 ; typI = 0
    exINF = -546 ; n2ex = 0.0
"""
# Stage complate
"""Le type est un indice
    La famille type's donne une mesure en plus
    Le typO ou le nombre à mettre en puissance
 nOmbre = 231684 ; typO = 0
    Le typI ou le point d'arrivée du nombre
 nIvele = 322564854120055 ; typI = 1
    Le typX ou l'exposant à son terme
eXSUP = 2.704361264537945 ; typX = 2.704361264537945
    Le typ2 ou la solution de type remarquable
n2ex = 322564854120052.0 ; typ2 = 4.0
 refute = [2.704361264537945, 322564854120052.0]  
"""
"""
2**-3 ou 1/2**3
"""
# f

Sans aucune excuse :mouarf:

11/03/2018, 08h02
Invité

Nombre**?

Dans le sujet, il y a la puissance qui basiquement augmente la masse du nombre exposé. N**2
Pour les filous comme moi, la puissance fait baisser la masse du nombre. N**.2

Mais ce qui me parait improbable c'est que le nombre positif mis en puissance, ne puisse parvenir à une masse négative. N**?
11/03/2018, 09h14
Sve@r

Citation:

Envoyé par toumic

Mais ce qui me parait improbable c'est que le nombre positif mis en puissance, ne puisse parvenir à une masse négative. N**?

Aucun nombre positif, élevé à quelque puissance que ce soit, ne peut donner un nombre négatif.

J'essaye de comprendre avec le code, à savoir aller au-delà de la limite 1.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #!/usr/bin/env python3.6 # -*- coding: utf-8 -*- # Bloc 1 nombre1 = 2354 nombre2 = 1 exposant = [0.1] puissance = nombre1 ** exposant[0] while puissance > nombre2: exposant[0] /= 10 puissance = nombre1 ** exposant[0] print('puissance', puissance, 'exposant', exposant[0]) print('n1: {} ** {} = pu {}'. format(nombre1, exposant[0], puissance))
L'exposant est divisé par 10, jusqu'à temps produire une égalité ou approche du nombre2.
exp[0] = 0.1, 0.01, 0.001,,,

Citation:

puissance 2.1736051072096334 exposant 0.1
puissance 1.0807321335265223 exposant 0.01
puissance 1.0077940882861816 exposant 0.001 # Ici le 1. est absent
puissance 1.000776688595282 exposant 0.0001
puissance 1.000077641726841 exposant 1e-05
puissance 1.0000077639014266 exposant 1.0000000000000002e-06 #Ce qui me gêne c'est le 1. de l'exposant
puissance 1.0000007763874301 exposant 1.0000000000000002e-07
puissance 1.000000077638716 exposant 1.0000000000000002e-08
puissance 1.0000000077638713 exposant 1.0000000000000003e-09
puissance 1.0000000007763872 exposant 1.0000000000000003e-10
puissance 1.0000000000776388 exposant 1.0000000000000003e-11
puissance 1.0000000000077638 exposant 1.0000000000000002e-12
puissance 1.0000000000007765 exposant 1.0000000000000002e-13
puissance 1.0000000000000777 exposant 1.0000000000000002e-14
puissance 1.0000000000000078 exposant 1e-15
puissance 1.0000000000000007 exposant 1.0000000000000001e-16
puissance 1.0 exposant 1e-17
n1: 2354 ** 1e-17 = pu 1.0

Résultat des courses, on s'arrête à un :)

11/03/2018, 12h00
wiztricks

Citation:

Envoyé par toumic

Résultat des courses, on s'arrête à un :)

Vous essayez de réinventer l'eau chaude?
N'importe quel nombre positif élevé à la puissance 0 donnera 1. Cà a été construit pour produire ce résultat. Vous pouvez trouver cela merveilleux mais comme les tours de magie, soit vous vous dites bêtement "ah... oh..." soit vous essayez de découvrir le truc et çà deviendra "bon sang mais bien sûr", avant de devenir "bof..." une fois qu'on vous aura resservi 50 fois la même soupe.

- W

Citation:

Envoyé par wiztricks

Vous essayez de réinventer l'eau chaude?
N'importe quel nombre positif élevé à la puissance 0 donnera 1. Cà a été construit pour produire ce résultat. Vous pouvez trouver cela merveilleux mais comme les tours de magie, soit vous vous dites bêtement "ah... oh..." soit vous essayez de découvrir le truc et çà deviendra "bon sang mais bien sûr", avant de devenir "bof..." une fois qu'on vous aura resservi 50 fois la même soupe.

- W

Après lecture de certains tutoriels, et notamment https://www.microsofttranslator.com/...le-decimal.php

Mais encore avec un désir d'approfondissement du sujet, aux alentours du module decimal.
Pour faire le même exercice en plus simple, j'ai décidé de m'atteler à la racine carrée du nombre. Ainsi que pas si tout bête que cela, on peut aller plus loin que le modèle :

Code:

nombre**.5

Bien sûr ce message s'autodétruira lorsqu'une erreur sera rencontrée...

Code:

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 -*-
# La justesse de la racine carrée
"""
MuSiC@ToumiC ConTenT
Présente: nombre_carrea.py
"""
from decimal import *
 
def nombre_carre(nbr):
    # Section de la racine² entière
    wh = wh2 = 0
    while wh2 < nbr:
        wh += 1
        wh2 = wh ** 2
        if wh2 == nbr:
            break
    else:
        wh -= 1
    # Secteur décimal
    decitab = []
    recital = 0
    copieur = [0]
    entiere = wh
    top = i9 = 0
    while (Decimal(image[0]) ** 2) < nbr and top == 0:
        for i in range(1, 10):
            if decitab:
                image[0] = (str(entiere) + '.' + recital + str(i))
            else:
                image[0] = (str(entiere) + '.' + str(i))
            if Decimal(image[0]) ** 2 > nbr:
                decitab.append(i - 1)
                recital = (''.join(str(d) for d in decitab))
                image[0] = (str(entiere) + '.' + recital)
                if Decimal(image[0]) ** 2 == nbr:
                    decitab.append(i)
                    recital = (''.join(str(d) for d in decitab))
                    top = rondeur[0] = 1
                    break
                break
            elif i == 9:
                i9 += 1
                if i9 > 9:
                    top = 1
                    break
                if Decimal(image[0]) ** 2 == nbr:
                    top = rondeur[0] = 1
                    break
                decitab.append(i)
                recital = (''.join(str(d) for d in decitab))
                image[0] = Decimal(str(entiere) + '.' + recital)
            elif Decimal(image[0]) ** 2 == nbr:
                decitab.append(i)
                recital = (''.join(str(d) for d in decitab))
                top = rondeur[0] = 1
                break
    else:
        # Contrôle des dizaines
        wer = .1
        while Decimal(image[0]) ** 2 > nbr:
            mer = str(wer)[2:]
            copieur[0] = Decimal(str(entiere) + '.' + recital + mer)
            wer /= 10
            if len(str(wer)) > 5:
                break
        print('REELrecite =', recital)
        print('REELnombre =', nbr)
        print('REELracine =', nbr ** .5)
 
nombre = 213265897458 # 21354687
print('nombre =', nombre)
image = {0: 0}
rondeur = [0]
nombre_carre(nombre)
print('image =', image[0], '\nimageoo2 =', Decimal(image[0]) ** 2)
if rondeur[0] == 1:
    print('Justesse de la racine²')

Je voulais mettre une demi résolution du problème, mais peu cher, je solutionne