Virgule décimale du nombre

Version imprimable

Bonjour
J'ai préparé un exposé au sujet d'une interprétation entière au nombre, j'obtiens un résultat qui par plusieurs approches paraissait moins évident. Aussi étant interpelé par l'absence de certains savoirs, je vous demande votre avis sur le problème :)
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 # !/usr/bin/env python 3.5 # -*- coding: utf-8 -*- # Nombre Réel a9_0 (1234567...) a9_0 = 30 # Ici 30, à vous :) a9_1 = 1 / a9_0 a9_R = 1 // a9_0 a9_Q = len(str(a9_1)) # print('a9_1&Q : ', a9_1, a9_R, a9_Q) ''' ******************************************* La nombre contient une quantité de chiffres Diviser ce nombre par un.. Donne la décimale unitaire 1/nombre est Commun aux nombres réels ''' n10_Q = 10 * (10 ** 300) na9_1 = int(a9_1 * n10_Q) na9_Q = len(str(na9_1)) #print('na9_1', na9_1, a9_Q) print('n9_1&Q', na9_1, na9_Q) ''' ******************************************* Le commun du nombre réel est décimal, il a une virgule En arpentant les décimales par multiples de 10, on a L'entier commun relatif au 1/nombre ''' #
Citation:

Bon
J’entreprends un traitement porté sur les nombres réels, et ce n’est pas la première démarche. Tout a commencé avec la recherche de résultats à analyser, avec l’aide du multiple commun général des nombres qui est un (1). Pour vous aider à imaginer les faits, visualisez : *1/nombre*
En définitive, les résultats « 1/nombre » s’avèrent être des justes comparateurs sans contraire, ils sont relatifs au multiple commun (1). Au début on commence par les petits nombres, et en allant au grandissime, la définition décimale va au-delà qu’une simple capacité d’interprétation.
Pour y parvenir…
# Nombre Réel « a9_0 = 30 »
En dividende le multiple commun (1), et en diviseur (a9_0).
# Quotient Réel « a9_1 = 1 / a9_0 »
Le quotient produit un nombre réel à grande dimension décimale, l’interprétation de cette production implique un calcul d’occupation. (na9_Q)
# Mesure de l’Entier « a9_Q = len(str(a9_1)) »
La mesure d’occupation donne le nombre de décimales à générer pour une lecture complète du nombre décimal (a9_1), vers sa définition entière expositionnée. L’équation « 10**a9_1 » produit un nombre décimal, il ne reste qu’à accroitre la puissance. (n10_Q = 10 *(10 ** 300))
# Nouvelle mesure « na9_1 = int(a9_1 * n10_Q) »
(En essayant une puissance égale à 400 = Message d’erreur Python…). La valeur entière du quotient réel (a9_1) « 30 au natif » a un zéro en fin de bande, ou Fin = Entier
« na9_1 » = Valeur exacte délimitée ou Puissance limitée D’où valeur inexacte. ?
_________________________________________________________
*1/nombre*
www.cabviva.com/agenph.html
Et concentrez-vous sur les images (résultats)

17/07/2016, 15h07
dividee

"justes comparateurs sans contraire" ? "La définition décimale va au-delà qu’une simple capacité d’interprétation" ? "l’interprétation de cette production implique un calcul d’occupation" ?

Est-ce que tout ce charabia a un sens ? Même si c'est le cas dans ta spécialité qui a l'air fort ésotérique, pour le commun des mortels c'est juste incompréhensible. Tu aurais sans doute plus de réponses si tu prenais la peine de formuler ta question de façon à ce plus de personnes puissent la comprendre...

EDIT: après avoir vu ses autres messages... en presque 10 ans sur DVP c'est la première fois que je vais utiliser la liste d'ignorés... Je conseille à tous ceux qui veulent conserver leur santé mentale de faire de même.
17/07/2016, 15h22
Invité

Citation:

Envoyé par dividee

"justes comparateurs sans contraire" ? "La définition décimale va au-delà qu’une simple capacité d’interprétation" ? "l’interprétation de cette production implique un calcul d’occupation" ?

Est-ce que tout ce charabia a un sens ? Même si c'est le cas dans ta spécialité qui a l'air fort ésotérique, pour le commun des mortels c'est juste incompréhensible. Tu aurais sans doute plus de réponses si tu prenais la peine de formuler ta question de façon à ce plus de personnes puissent la comprendre...

Veuillez m'en excuser :)

Vous allez me faire pleurer :mouarf:

Le minimum

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
def decint():
    a9_0 = 1 * (30**1)
    a9_Q = 1 / a9_0
    # a9_0 : Le nombre contient une quantité de chiffres
    # a9_Q : Diviser ce nombre par un.. Donne la décimale unitaire
    # 1/nombre est Commun aux nombres réels
    n10_Q = 10 * (10 ** 300)
    na9_E = int(a9_Q * n10_Q)
    na9_L = len(str(na9_E))
    print('n9_1&Q', na9_E, na9_L)
    # a9_Q : Le commun du nombre réel est décimal, il a une virgule
    # n10_Q : En arpentant les décimales par multiples de 10, on a
    # na9_E : L'entier commun relatif au 1/nombre
decint()

Citation:
Envoyé par toumic
Vous allez me faire pleurer :mouarf:

Le minimum
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 # !/usr/bin/env python 3.5 # -*- coding: utf-8 -*- def decint(): a9_0 = 1 * (30**1) a9_Q = 1 / a9_0 # a9_0 : Le nombre contient une quantité de chiffres # a9_Q : Diviser ce nombre par un.. Donne la décimale unitaire # 1/nombre est Commun aux nombres réels n10_Q = 10 * (10 ** 300) na9_E = int(a9_Q * n10_Q) na9_L = len(str(na9_E)) print('n9_1&Q', na9_E, na9_L) # a9_Q : Le commun du nombre réel est décimal, il a une virgule # n10_Q : En arpentant les décimales par multiples de 10, on a # na9_E : L'entier commun relatif au 1/nombre decint()
Si vous vous contentez de supprimer charabia "français" pour laisser le charabia Python...
Sûr qu'à la fin, il y a moins de charabia à lire mais est-ce que cela rend votre prose plus compréhensible?
Dommage d'avoir à communiquer avec des humains normaux pour obtenir de l'aide, mais sur les forums de DVP, c'est encore le cas.

- W

Citation:

Envoyé par wiztricks

Si vous vous contentez de supprimer charabia "français" pour laisser le charabia Python...
Sûr qu'à la fin, il y a moins de charabia à lire mais est-ce que cela rend votre prose plus compréhensible?
Dommage d'avoir à communiquer avec des humains normaux pour obtenir de l'aide, mais sur les forums de DVP, c'est encore le cas.

- W

Je fais de mon mieux qui n'est visiblement pas agréable à lire, je veux juste savoir si cette fonction est vraie.

Lorsque di = 1 "a9_Q = 1 / a9_0" ou "a9_Q = 1 / 1" a pour quotient 1
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 di = 1 def decint(di): a9_0 = di a9_Q = 1 / a9_0 # a9_0 : Le nombre contient une quantité de chiffres # a9_Q : Diviser ce nombre par un.. Donne la décimale unitaire # 1/nombre est Commun aux nombres réels n10_Q = 10 * (10 ** 300) na9_E = int(a9_Q * n10_Q) na9_L = len(str(na9_E)) print('n9_1&Q', na9_E, na9_L) # a9_Q : Le commun du nombre réel est décimal, il a une virgule # n10_Q : En arpentant les décimales par multiples de 10, on a # na9_E : L'entier commun relatif au 1/nombre
Cette fonction produit ce résultat

Citation:

n9_1&Q 10000000000000000525047602552044202487044685811081591549158541155118024579889081957863713750804478640437044438328838781769425232353604305756447921847867069828483872009265758037378302337947880900593689532349707999450811190389676408800746527427801424945792587888200568428381156694721963868654594005401600 302

C'est ici que je cale, et que je n'ose poser de question de peur d'effrayer le lecteur :)
À part ceci, si vous pouvez m'éclairer ?

17/07/2016, 20h38
wiztricks

Citation:

Envoyé par toumic

Je fais de mon mieux qui n'est visiblement pas agréable à lire, je veux juste savoir si cette fonction est vraie.

Lorsque di = 1 "a9_Q = 1 / a9_0" ou "a9_Q = 1 / 1" a pour quotient 1

Une fonction n'est ni vraie ni fausse. Elle peut réaliser un algorithme correctement(ou pas). Mais si vous ne décrivez pas cet algorithme (ou le résultat que vous voulez obtenir) la fonction peut "fonctionner" sans pour autant traduire correctement l'algorithme qu'elle cherche à réaliser. Et si on ne sait pas ce que vous cherchez à faire, c'est pas juste en lisant le code qu'on pourra l'imaginer (et vous répondre).

- W

Direction la Lune

J'ai écris un code qui traduit mes inquiétudes au sujet du quotient de la division
Il exprime un grand nombre1 copié et collé à nombre2, avec pour unique différence l'unité qui est incrémentée de 2
Comme j'ai déjà roulé ma bosse avec les nombres et leurs divisions, jusqu'ici tout va bien les quotients ont étés satisfaisants
La leçon retenue est que deux nombres même consécutifs à l'unité, n'ont pas le même quotient

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
 
# Ce programme a un résultat erroné avec les grands nombres
# Soit que 2 nombres différents n'ont pas le même quotient
nombre1 = 12345678901234567890123456789012345678901234567890123456787
nombre2 = 12345678901234567890123456789012345678901234567890123456789
quotient1 = 1 / nombre1
quotient2 = 1 / nombre2
print('1', quotient1)
print('2', quotient2)
if quotient1 == quotient2:
    # Ce n'est pas normal
    print('Non (1 2)')
 
nombre3 = 123456789012345677
nombre4 = 123456789012345679
quotient3 = 1 / nombre3
quotient4 = 1 / nombre4
print('3', quotient3)
print('4', quotient4)
if quotient3 == quotient4:
    # Ce n'est pas normal
    print('Non (3 4)')
 
# C'est à partir d'ici que la division est juste ?
nombre5 = 12345678901234567
nombre6 = 12345678901234569
quotient5 = 1 / nombre5
quotient6 = 1 / nombre6
print('5', quotient5)
print('6', quotient6)
if quotient5 == quotient6:
    print('Non (5 6)')
else:
    print('Oui (5 6)')

Vous vouliez comprendre la raison de ce raisonnement, c'est ma deuxième passion après les gammes musicales
En terme du nombre aussi intéressant que la gamme, de la belle mécanique :)
Et mon algorithme des (petits) nombres premiers, comprenez qu'un passage au grand nombre me soit irréaliste
Je ne saurais pas vraiment résoudre ce problème sans d'autres connaissances

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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
nom_1er = []    # Série des nombres premiers 
tab_1er = []    # Série des unités nombre/(nombre*2)
# Les nombres aux micros unités
oko = [0]
h_ex = [0]
h_co = [0]
y1 = [0]
t_i = - 1
hip = 30        # Nombre à traiter
# Recherche des antécédants
for y in range(hip):
    oko[0] = 0
    h_ox = h_m = 0
    y1[0] = y + 1
    y6 = y1[0] % 6  # Calcul de typage
    # Le reste = Parité hexa du quotient 
    if y6 == 2 or y6 == 3:
        y6 = 1
    if y6 == 1 or y6 == 5:
        # L'"y1[0]" = Plafond épisodique
        y2 = y1[0] * 2
        y0 = y1[0] + 1
        # print(y2, '=', y1[0], '*2')
        for h in range(y0, y2):
            h_ex[0] = h / y1[0]     # Dividende entier croissant
            # L'"h_ex[0]" = La précision de l'intervalle
            # print('h_ex', h_ex[0], '= h ', h, ' / ', y0)
            if h == y0:
                h_co[0] = h_ex[0]   # Première unité (1/nombre)
                h_ox = 1
            # Recherche dans l'archivage
            for t1 in tab_1er:
                if t1 == h_ex[0]:
                    oko[0] = 1      # Multiple inférieur présent
                    break
            if oko[0] == 1:
                break
        # L'"oko[0]" = Premier commun en écriture
        if oko[0] == 0:
            t_i += 1
            if h_ox == 1:
                h_ex[0] = h_co[0]   # nombre 1er en écriture
            tab_1er.append(h_ex[0])
            nom_1er.append(y1[0])
            # nom_6 = nom_1er[t_i] % 6      # Comparaison opère ?
            print(nom_1er[t_i], 'tab', tab_1er[t_i])
    else:
        pass

Direction la Lune :)

Salut,

Ce que vous constatez est "normal" avec la représentation par défaut des nombres flottants. Si vous voulez une précision plus importante, vous avez les possibilités du module decimal à exploiter:
Code:

1 2 3 4 5 6 >>> from decimal import Decimal, getcontext >>> getcontext().prec = 100 >>> a = 1/Decimal(12345678901234567890123456789012345678901234567890123456787) >>> b = 1/Decimal(12345678901234567890123456789012345678901234567890123456789) >>> a == b False
Avec "moins" de précision:
Code:

1 2 3 4 5 6 >>> getcontext().prec = 10 >>> a = 1/Decimal(12345678901234567890123456789012345678901234567890123456787) >>> b = 1/Decimal(12345678901234567890123456789012345678901234567890123456789) >>> a == b True >>>
- W

Citation:

Envoyé par wiztricks

Salut,

Ce que vous constatez est "normal" avec la représentation par défaut des nombres flottants. Si vous voulez une précision plus importante, vous avez les possibilités du module decimal à exploiter:

Code:

1
2
3
4
5
6
>>> from decimal import Decimal, getcontext
>>> getcontext().prec = 100
>>> a = 1/Decimal(12345678901234567890123456789012345678901234567890123456787)
>>> b = 1/Decimal(12345678901234567890123456789012345678901234567890123456789)
>>> a == b
False

Avec "moins" de précision:

Code:

1
2
3
4
5
6
>>> getcontext().prec = 10
>>> a = 1/Decimal(12345678901234567890123456789012345678901234567890123456787)
>>> b = 1/Decimal(12345678901234567890123456789012345678901234567890123456789)
>>> a == b
True
>>>

- W

Il ne me reste plus qu'à comparer un résultat juste avec mon pseudo-illusoire "n10_Q = 10 * (10 ** 300)" :)
Mais cela fait partie d'un cheminement à découvrir plus amplement

Merci wiztricks ou = :)

PS reste à faire une représentation entière "sans virgule"
Il me faut comprendre comment, à savoir quand ou combien de chiffres pour finaliser cette division
En réglant la valeur "Decimal" à 500, j'obtiens un quotient avec une note (e)
Je vais essayer en testant une probable finalité en testant le reste de la division, soit reste(0) = quotient juste
Il y a sûrement des quotients qui vont à l'infini alors :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
from decimal import Decimal, getcontext
getcontext().prec = 500
nombre1 = 12345678901234567890123456789012345678901234567890123456787
nombre2 = 12345678901234567890123456789012345678901234567890123456789
quotient1 = 1 / Decimal(nombre1)
quotient2 = 1 / Decimal(nombre2)
qlong_q1 = len(str(quotient1))
print('Q1', quotient1)
#print('Q2', quotient2)
if quotient1 == quotient2:
    # Ce n'est pas normal
    print('Non (1 2)')
else:
    print('qlong_q1', qlong_q1)
    print('q-q', quotient2 - quotient1)

Puis, une approche entière du nombre décimal

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
from decimal import Decimal, getcontext
 
precisi = 500       # precisi
getcontext().prec = precisi
nombre1 = 12345678901234567890123456789012345678901234567890123456787
nombre2 = 12345678901234567890123456789012345678901234567890123456789
quotient1 = (nombre1 + 1) / (Decimal(nombre1)) * 2
quotient2 = (nombre2 + 1) / (Decimal(nombre2)) * 2
qlong_q01 = len(str(quotient1))
print('Q1', quotient1, qlong_q01)
qseto_q10 = quotient1 * (10 ** Decimal((precisi / 2)))
#print('Q2', quotient2)
if quotient1 == quotient2:
    # Ce n'est pas normal
    print('Non (1 2)')
if int(quotient1) > 1:
    print('Q1 > 1', int(quotient1), int(qseto_q10))

Et enfin un résultat proche de ma réalité :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
from decimal import Decimal, getcontext
nombre1 = 12345678901234567890123456789012345678901234567890123456787
nombre2 = 12345678901234567890123456789012345678901234567890123456789
qprec_1 = len(str(nombre1)) * 10
precisi = qprec_1
getcontext().prec = precisi
quotient1 = (nombre1 + 1) / (Decimal(nombre1)) * 2
quotient2 = (nombre2 + 1) / (Decimal(nombre2)) * 2
qlong_q01 = len(str(quotient1))
print('Q1', quotient1, qlong_q01)
qseto_q10 = quotient1 * (10 ** Decimal((precisi / 2)))
#print('Q2', quotient2)
if quotient1 == quotient2:
    # Ce n'est pas normal
    print('Non (1 2)')
if int(quotient1) > 1:
    print('Q1 > 1', int(quotient1), qseto_q10)

Fin de soirée sur la lune :)

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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
# Valide pour les nombres entiers positifs ou négatifs
# Les caractères autres que (0,1,2,3,4,5,6,7,8,9) = 0
from decimal import Decimal, getcontext
nom_1er = []    # Série des nombres premiers 
tab_1er = []    # Série des unités nombre/(nombre*2)
# Les nombres aux micros unités
oko = [0]
h_ex = [0]
h_co = [0]
y1 = [0]
t_i = - 1
qpe = hpn = 0
uti_1 = input('Entrer un nombre entier positif ou négatif : ')
bip = len(uti_1)
hpost = ""
hrang = -1
for hb in uti_1:
    pp_2 = 0
    hrang += 1
    if hrang == 0 and hb == '-':
        hpn = 1
    else:
        for ii in range(10):
            if hb == str(ii):
                hpost += hb
                pp_2 = 1
                break
        if pp_2 == 0:
            hpost += '0'
if hpn == 1:
    hpo_2 = int(hpost)
    hne_2 = hpo_2 - (hpo_2 * 2)
    hpost = str(hne_2)
elif int(hpost) == 0:
    hpost += '1'
hip = int(hpost)
if hip < 0:
    sip = - 1
else:
    sip = 1
    qpe = 1         # Pour égaler le caractère du sign "-"
fac_1er = sip / hip
qfact_1 = len(str(fac_1er))
qprec_1 = len(str(hip)) + qpe
precisi = qprec_1 * qfact_1
getcontext().prec = precisi
print(hip, 'precision', precisi, '=(hip)', qprec_1, '*(fac)', qfact_1)
# Recherche des antécédants
for y in range(0, hip, sip):
    oko[0] = 0
    h_ox = h_m = 0
    y1[0] = y + sip
    y6 = y1[0] % 6  # Calcul de typage
    # Le reste = Parité hexa du quotient
    if y < 7:
        if 5 > y6 > 1:
            y6 = 1
    if y6 == 1 or y6 == 5:
        # L'"y1[0]" = Plafond épisodique
        y2 = y1[0] * 2
        y0 = y1[0] + sip
        for h in range(y0, y2, sip):
            h_ex[0] = h / Decimal(y1[0])     # Dividende entier croissant
            # L'"h_ex[0]" = La précision de l'intervalle
            if h == y0:
                h_co[0] = h_ex[0]   # Première unité (1/nombre)
                h_ox = 1
            # Recherche dans l'archivage
            for t1 in tab_1er:
                if t1 == h_ex[0]:
                    oko[0] = 1      # Multiple inférieur présent
                    break
            if oko[0] == 1:
                break
        # L'"oko[0]" = Premier commun en écriture
        if oko[0] == 0:
            t_i += 1
            if h_ox == 1:
                h_ex[0] = h_co[0]   # 1/nombre en écriture
            tab_1er.append(h_ex[0])
            nom_1er.append(y1[0])
            # nom_6 = nom_1er[t_i] % 6      # Comparaison opère ?
            print(nom_1er[t_i], 'tab', tab_1er[t_i])
    else:
        pass