Voir le flux RSS

music univers

Deux façons de traiter avec les nombres premiers multiples

Noter ce billet
par , 30/07/2016 à 22h18 (483 Affichages)
Bonne aventure avec les nombres, et tels qu'ils sont présentés. Ils auront l'aperçu d'une image de synthèse faisant la réunion des points majeurs, démontrant les premières cadences des nombres entiers étant premiers multiples communs.

Citation Envoyé par toumic
Il est important de connaître ces deux sujets
Il s’agit de deux approches différentes sur les nombres entiers, l’une fait le rapprochement avec la base des six unités. L’autre perçoit les intervalles produits par la précision des quotients.
Un nombre a l’expression qu’on en tire ; Il est simple et ordonné, c’est le traitement qui est effectué sur lui exprimant la recherche. Il y a une recherche qui suit son cours, elle prolonge le volume pour s’y retrouver dans le raisonnement du nombre premier multiple. Le nombre multiplié (par 1, 2, 3,) a sa propre cadence, à l’origine premier multiple à valeur égale multiplié par 1. Ce n’est pas l’infini qui est analysé, mais la cadence de chaque nombre premier à l’aide d’un tableau résumant les résultats communs. Comme il a été dit, il y a deux traitements sur les nombres. Deux types de résultats pour une unique série de nombres entiers, tous les deux sont mêlés à la division.
La division a un reste comme résultat, à savoir qu’en ayant six comme diviseur et le nombre à fonction dividende. Son reste donne son type de nombre (pair, impair,), et ainsi limiter son transfert pour un traitement inutile. Les quotients sont des intervalles estimés en décimales, ils répondent à la question suivante « - Est-ce un nombre entier multiple premier ? ». Le type donné par le reste n’est pas immédiat pour déterminer avec précision sa valeur en tant que « multiple », puisqu’il détermine dans qu’elle série le nombre est rangé. Puisqu’autant d’assurer une totale portabilité aux nombres répartis sur les six séries de types, qu’un alignement des nombres premiers sur deux lignes distinctes. Aux restes systématisés aux rapports d’une structure soit empilée, soit rayonnante. Le tableur comme outil de recherche pour empiler les nombres entiers en couches de lignes et six colonnes à types sériels. C’est pour avoir construit ce premier tableau privilégiant les détails harmoniques des premiers multiples, nettement plus visibles avec un profond empilement des alinéas numériques.
Parfois, il est impossible de comprendre une logique sans un possible appoint visuel. Dans un ensemble cohérent, simple à comprendre, et se présentant sans superflu. L’esthétique de la présentation à été rendue accessible en ayant réduit l’apparition des ordonnées, afin de laisser une belle part de lecture à cette expression visuelle. Dans le but de reconnaître en un mécanisme répétitif, une première empreinte qui reflèterait « une » clé du champ numérique.
Imager ou mirage ?
Nom : Classnph.png
Affichages : 100
Taille : 398,6 Ko

Classnph.pdf

Parfois le besoin d'un calculateur est ressenti, alors essayez ceci

Code python : 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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
# Cette première version produit les nombres premiers. Selon la méthode de l'intervalle numérique, ainsi :
# n = nombre. 1/n va vers n/n (de 1 à nombre). 1/n. 2/n. 3/n. 4/n... Et,la série des quotients-intervalles
# À chaque quotient s'effectue une recherche préalable. En faisant la même suite opératoire à plus petit niveau
# Exemple : n = Nombre = 3. d = Dividende. q = Quotient. [q = d / n] = Intervalle. La demande des nombres premiers
# produit les plus petits premiers multiples, ou multiples premiers, ils n'ont pas de multiple inférieur.
# Pour y parvenir, il faut chercher depuis le début de la série des nombres inférieurs au nombre demandé.
# Aussi à chaque incrémentation du dividende, le dividende devient le nombre aux intervalles-quotients.
# Ce nombre-dividende (n2) devenu diviseur avec des niveaux d'intervalles (d2). [q2 = d2 / n2]. 1/n2. 2/n2. 3/n2...
# n2 produit une série de quotients, et l'un d'entre eux pourrait même être un multiple inférieur.
# Ce qui veut dire que la série des intervalles_quotients d'un nombre, peut avoir plusieurs correspondances.
# Toutes liées à des quotients multiples inférieurs...
##
# 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 = hp1 = 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 == '-':
        hpost += '0'
        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 int(hpost) == 0:
    hpost += '1'
if hpn == 1:
    hpo_2 = int(hpost)
    hne_2 = hpo_2 - (hpo_2 * 2)
    hpost = str(hne_2)
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])
            print(nom_1er[t_i])
    else:
        pass

Avec le traitement ci-dessus, on trouve les premiers multiples grâce aux quotients. C'est en relation avec la figure colorée en haut, que s'est construit le traitement primo, étant les prémices des premiers constants ou basique.

Code python : 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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
from math import sqrt
import time
 
begin = time.time()
n_def = [0]
# TROIS
# La fonction de production des premiers
def premier(point, num):
    if point == 0:          # Valeur inconstante
        n_def[0] += 1
        # print(n_def[0], 'SIX n_primo', n_dep)
n_dep = n_depart = 0
n_arr = n_arrive = 300
n_distan = (n_arrive - n_depart) + 1
# UN
# Le typage donne le rang des premiers
for n in range(n_distan):
    n_poin = 0
    y6 = n_dep % 6          # Calcul de typage
    # Au premier niveau des premiers
    if n_dep < 7:
        if 5 > y6 > 1:
            y6 = 1
    # DEUX
    # Passage du type premier possible
    if y6 == 1 or y6 == 5:
        n5_dep = n_dep / 5      # Constante originale en croix
        n7_dep = n_dep / 7      # Constante originale verticale
        ns_dep = sqrt(n_dep)    # Constante originale rare
        # Traitement des constantes et premier niveau
        if n5_dep - int(n5_dep) == 0 and n_dep != 3 and n_dep != 5:
            n_poin = 1
        if n7_dep - int(n7_dep) == 0 and n_dep != 7:
            n_poin = 1
        if ns_dep - int(ns_dep) == 0 and n_dep != 1:
            n_poin = 1
        # Appel avec transmission de la constante
        premier(n_poin, n_dep)
    n_dep += 1
print("primo", "Temps @ toumic = %s" %(time.time() - begin), 'len', n_def[0])

D'un côté son résultat n'est pas celui qu'on espère, mais la suite de ces constantes (5, 7, carré)
Alors il a fallut ajouter une recherche en sélectionnant les signes premiers du diviseur (nue = num / nu)

Code python : 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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
from math import sqrt
import time
 
begin = time.time()
n_def = [0]
# TROIS
# La fonction de production des premiers
def premier(point, num):
    if point == 0:          # Valeur inconstante
        nu_0 = 0
        if num > 7:
            for nu in range(2, int((num / 2) + 1)):
                u6 = nu % 6     # Calcul de typage
                # Passage du type premier possible
                if u6 == 1 or u6 == 5:
                    nue = num / nu
                    if float.is_integer(nue) == True:
                        nu_0 += 1
                        break
        # QUATRE
        # Expression Python
        if nu_0 == 0:        
            n_def[0] += 1
            # print(n_def[0], 'SIX seconde', n_dep)
n_dep = n_depart = 0
n_arr = n_arrive = 400
n_distan = (n_arrive - n_depart) + 1
# UN
# Le typage donne le rang des premiers
for n in range(n_distan):
    n_poin = 0
    y6 = n_dep % 6          # Calcul de typage
    # Au premier niveau des premiers
    if n_dep < 7:
        if 5 > y6 > 1:
            y6 = 1
    # DEUX
    # Passage du type premier possible
    if y6 == 1 or y6 == 5:
        n5_dep = n_dep / 5      # Constante originale en croix
        n7_dep = n_dep / 7      # Constante originale verticale
        ns_dep = sqrt(n_dep)    # Constante originale rare
        # Traitement des constantes et premier niveau
        if n5_dep - int(n5_dep) == 0 and n_dep != 3 and n_dep != 5:
            n_poin = 1
        if n7_dep - int(n7_dep) == 0 and n_dep != 7:
            n_poin = 1
        if ns_dep - int(ns_dep) == 0 and n_dep != 1:
            n_poin = 1
        # Appel avec transmission de la constante
        premier(n_poin, n_dep)
    n_dep += 1
print("sec", n_distan - 1, "Temps @ toumic = %s" %(time.time() - begin), 'len', n_def[0])

Ce précédent code (seconde) filtre les nombres, tout comme le fait ("%6", typage).
À lui seul, il ne crée pas un réel résultat. Surtout lorsque le nombre de départ est supérieur,
à ce moment et vu la séquence des fonctions. Vont apparaître des soi-disant premiers
Le code général a été compacté, et sa résultante semble exacte

Code python : 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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
import time
from math import sqrt
begin = time.time()
n_nbr = []
n_def = 0
q_dep = n_dep = n_depart = 0
n_arr = n_arrive = 100000
n_distant = (n_arrive - n_depart)
n_dep -= 1
if q_dep > 1000:
    s_dep = int(sqrt(n_distant) * 10)
else:
    s_dep = q_dep
for n in range(n_distant + 1):
    n_dep += 1
    y6 = n_dep % 6
    if n_dep < 7 and y6 in (2, 3, 4):
        y6 = 1
    if y6 in (1, 5):
        nue_0 = 0
        if nue_0 == 0:    
            for nue in n_nbr:
                # noinspection PyCallByClass
                if nue != 1 and float.is_integer(n_dep / nue):
                    nue_0 += 1
                    break
        if nue_0 == 0:
            for d_dep in range(3, s_dep):
                # noinspection PyCallByClass
                if (d_dep % 6) in (1, 5) and float.is_integer(n_dep / d_dep):
                    nue_0 += 1
                    break
        if nue_0 == 0:
            n_def += 1
            n_nbr.append(n_dep)
print(n_nbr)
print('min3_22:', n_distant, '| time : %s' % (time.time() - begin),
      '| len:', n_def)

Puis, j'ai copié sous Pycharm (mon sous dictateur), qui n'a pas été suivit jusqu'au bout de son Python. C'est en essayant de suivre les conseils, que le code s'est raccourcit. Assez rigolo pour une première )

Code python : 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
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
import time

begin = time.time()
n_nbr = []
n_def = 0
n_dep = n_depart = 0
n_dep -= 1
n_arrive = 300000
n_distant = (n_arrive - n_depart)
# Le typage donne le rang des premiers
for n in range(n_distant + 1):
    n_dep += 1
y6 = n_dep % 6          # Calcul de typage
    # Au premier niveau
if n_dep < 7:
        if 5 > y6 > 1:
            y6 = 1
# Passage de type phase tableau
if y6 in (1, 5):
        nue_0 = 0
# Lecture n_nbr = tableau
for nue in n_nbr:
            # noinspection PyCallByClass
if nue != 1 and float.is_integer(n_dep / nue):
                nue_0 += 1
break
# Expression (:Python:) phase premier
if nue_0 == 0:
            vu_0 = 0
if n_dep > 7:
                # Recherche origine premier
for vu in range(2, int((n_dep / 2) + 1)):
                    v6 = vu % 6     # Typage
                    # noinspection PyCallByClass
if v6 in (1, 5) and float.is_integer(n_dep / vu):
                        vu_0 += 1
break
            if vu_0 == 0:
                n_def += 1
n_nbr.append(n_dep)
print(n_nbr)
print("min", n_distant, "| time %s" % (time.time() - begin), '| len', n_def)

[/CODE]
Résultat "print"
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
[1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999]
min 3000 | time 0.2721080780029297 | len 431
Et quand j'ai besoin de savoir quels sont les multiples relatifs à un nombre, j'utilise ceci ci-bas
Car quant à la recherche manuscrite qui permet de cumuler les données, à suivre
Code python : 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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
import time
from math import sqrt
num = 365
sqrnum = sqrt(num)
sqr = int(sqrt(num))
print(sqrnum)
 
'''def toumic(tot):
    begin = time.time()
    for i in range(tot):
        for y in range(tot):
            if i * y == tot:
                print("toumic = %s * %s = %s" % (i, y, tot))
    print("toumic = Done at: %s" %(time.time() - begin))'''
 
def vinss(tot, max_):
    begin = time.time()
    for i in range(max_):
        for y in range(max_ - 1, tot):
            if i * y == tot:
                print("vinss = %s * %s = %s" % (i, y, tot))
    print("vinss = Done at: %s" %(time.time() - begin))
 
# toumic(num)
vinss(num, sqr + 1)

@

Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Viadeo Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Twitter Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Google Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Facebook Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Digg Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Delicious Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog MySpace Envoyer le billet « Deux façons de traiter avec les nombres premiers multiples » dans le blog Yahoo

Mis à jour 09/10/2016 à 09h25 par toumic

Catégories
Programmation , Python

Commentaires