Discussion :

[Invité]

Tourner à la dérision les voluptés des couples de multiplicateurs, est une bonne manière de danser. Le gain de temps se fait par la clairvoyance, qui va bien souvent au-delà des mots. Pour être bref ce qui change dans la mesure de ce programme, c'est son côté de la première recherche (boucle for ou while), avant de trouver un seul multiple commun. Le fait des écarts dus aux nombres premiers multipliés qui peuvent être conséquents, alors de ce fait il s'agit de "boucler" sur plusieurs plans à la fois.


C'est ce qui a été fait, en plus de l'exercice de non "bouclage" en termes des multiples dans la fonction :socom():. Selon que le couple de niveau bas soit possiblement le produit d'une puissance (22*22)...

Je vous laisse découvrir ce que quelques croutons améliorent l'utilitaire en fonction des ses prochaines évolutions, un temps de gagné pour des nouveaux exercices appliqués

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Considérable simplifié de NphParty_8a
# Programme  Nphony_4 : 22 avril 2017
import time
from math import sqrt
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    norg = n_
    sq2 = int(sqrt(sqrt(norg)))
    sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        corg = c_
        if c_ < 2:
            nivbas.append(1)
            nivbas.append(1 // 1)
        else:
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs1 = csq1
            cs2 = sq2
            n0 = n1 = cn = 0
            while 1:
                n0 -= 1
                n1 += 1
                c0 = cs1 - n0
                c1 = cs2 + n1
                if not corg % c0:
                    nivbas.append(c0)
                    nivbas.append(corg // c0)
                    cn = 1
                    break
                elif not corg % c1:
                    nivbas.append(c1)
                    nivbas.append(corg // c1)
                    cn = 1
                    break
                if cn == 1:
                    break
        if nivbas[0] == nivbas[1]:
            bi0[0] = 1
    def socom():
        so2 = 0
        for so in nivbas:
            so2 += 1
            nivsub = []
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        for mn in subips:
            for mo in subdvs:
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            nivorg.sort()
    def communs(o_):
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    socom()
    multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0], sq2, sq3)
    print('Nphony_4.py En {}'.format(time.time() - d0))
uno = 10101010101010101010
print('Cosmic', uno)
nombre(uno)

[Invité]

Tourner à la dérision les voluptés des couples de multiplicateurs, est une bonne manière de danser. Le gain de temps se fait par la clairvoyance, qui va bien souvent au-delà des mots.

Et pour plaisanter un mode sans bug, anti négatifs et nuls

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
103
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Considérable simplifié de NphParty_8a
# Programme  Nphony_4a : 22 avril 2017
import time
from math import sqrt
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    norg = n_
    if n_ < 1:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        corg = c_
        if c_ < 2:
            nivbas.append(1)
            nivbas.append(1 // 1)
        else:
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs1 = csq1
            cs2 = sq2
            cn = 0
            while 1:
                cs1 -= 1
                cs2 += 1
                if not corg % cs1:
                    nivbas.append(cs1)
                    nivbas.append(corg // cs1)
                    cn = 1
                    break
                elif not corg % cs2:
                    nivbas.append(cs2)
                    nivbas.append(corg // cs2)
                    cn = 1
                    break
                if cn == 1:
                    break
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        so2 = 0
        for so in nivbas:
            so2 += 1
            nivsub = []
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        for mn in subips:
            for mo in subdvs:
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            nivorg.sort()
    def communs(o_):
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    socom()
    multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0], sq2, sq3)
    print('Nphony_4a.py En {}'.format(time.time() - d0))
uno = 12345678987654321
print('Cosmic', uno)
nombre(uno)

[Invité]

Bonjour

La dernière version nommée "nphony_10" produit une recherche de multiplicateur sur trois plans

1. De la racine carrée 1 à la racine carrée 2
2. De la racine carrée 2 à la racine carrée 1
3. De la racine carrée 2 à zéro

Les nombres qui vont de zéro à quinze ont une faible racine carrée, ils ont un conditionnement spécial (voir le code).

Les fonctions "def" ont volontairement étés laissés, car pour les nombres dépassant 15 chiffres les multiples sont plus nombreux.
Le temps de calcul pour cette version est long, ainsi l'étape suivante est de réaliser un démultiplication parmi les multiples non connus.

Ce qui peut être un mystère ressemblant au mètre du charpentier, qui va se déplier en créant un chemin d'accès aux sous multiples afin de les remonter plus aisément.

Voici le code

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Programme  Nphony_10 : 29 avril 2017
"""
Découvrir les multiples liés à un NOMBRE
"""
import time
from math import sqrt
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    '''Introduction du NOMBRE'''
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        '''Recherche d'un élément lié'''
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            # Essayer sans condition
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1+1 # :csq1: Racine Carrée NOMBRE
            cs20 = cs21 = sq2+1 # :sq2: R C de :csq1:
            while 1:
                if csq1 < 4:
                    w10 = 1
                #print('10', cs10)
                if not corg % cs10\
                   and cs10 > cs21-2:
                    # Décrément de :cs10: à :cs21:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21\
                   and cs21 < cs10+2:
                    # Incrément de :cs21: à :cs10:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    cs10 -= 1
                    cs20 -= 1
                    cs21 += 1
 
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        '''Alignement des multiplicateurs'''
        so2 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            nivsub = []
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        '''Multiplication élémentaire'''
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        '''Production des multiplicandes'''
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed',len(nivorg),'typ',norg % 6,'sq1',sq1[0],sq2,sq3)
    print('Nphony_10.py En {}'.format(time.time() - d0))
uno = 16
print('Cosmic', uno)
nombre(uno)
"""
Exemple long premier 326579102297565526099
"""

[Invité]

Bonjour

Code corrigé

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Programme  Nphony_1a : 30 avril 2017
"""
Découvrir les multiples liés à un NOMBRE
"""
import time
from math import sqrt
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            # Essayer sans condition
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1+1 # :csq1: Racine Carrée NOMBRE
            if sq2 == 1:
                cs20 = cs21 = sq2 # :sq2: R C de :csq1:
            else:
                cs20 = cs21 = sq2-1
            cs30 = sq2*3
            w1 = w2 = w3 = 0
            while 1:
                if csq1 < 4:
                    w10 = 1
                if not corg % cs10:
                    # Décrément de :cs10: à :cs21:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20\
                     and sq2 > 1:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21\
                     and cs21 > 1:
                    # Incrément de :cs21: à :cs10:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    if cs10 > cs30:
                        cs10 -= 1
                    else:
                        w1 = 1
                    if cs21 < cs30: 
                        cs21 += 1
                    else:
                        w2 = 1
                    if len(nivbas) == 0\
                       and w2 == 1:
                        cs20 -= 1
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        so2 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            nivsub = []
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed',len(nivorg),'typ',norg % 6,'sq1',int(sq1[0]),sq2,sq3)
    print('Nphony_11a.py En {}'.format(time.time() - d0))
uno = 987654319
print('Cosmic', uno)
nombre(uno)
"""
Exemple long premier 326579102297565526099
Erreur 20021957 (absence multiple 191)
"""

Dernier multi ultime

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
from math import sqrt
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Suite  à   Nphony_11 : 30 avril 2017
# Programme Nphonic_0a : 1 mai 2017
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    '''Introduction du NOMBRE'''
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1+1 # :csq1: Racine Carrée NOMBRE
            if sq2 == 1:
                cs20 = cs21 = sq2 # :sq2: R C de :csq1:
            else:
                cs20 = cs21 = sq2-1
            cs30 = int(sq2+(sq3**2.5))
            cs40 = int(csq1+(sq3**2.5))
            w2 = 0
            while 1:
                if csq1 < 4:
                    w10 = 1
                if not corg % cs10:
                    # Décrément de :cs10: à :cs21:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20\
                     and sq2 > 1:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21\
                     and cs21 > 1:
                    # Incrément de :cs21: à :cs10:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    if cs10 > cs40:
                        cs10 -= 1
                    if cs21 < cs30: 
                        cs21 += 1
                    else:
                        w2 = 1
                    if len(nivbas) == 0\
                       and w2 == 1:
                        cs20 -= 1
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        so2 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed',len(nivorg),'typ',norg % 6,'sq1',int(sq1[0]),sq2,sq3)
    print('Nphonic_0a.py En {}'.format(time.time() - d0))
uno = 621354658784521325689
print('Cosmic', uno)
nombre(uno)

[Invité]

Bonjour, j'ai revisité le moyen de recherche en boucle d'un multiple dont le voisinage est estimé à

Code :

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

cs40 = int(csq1 - (sq3 ** 2.5))

Ce qui est valable pour les nombres à petite quantité de chiffres, ne l'est pas pour les grands nombres. Il faut penser que la boucle de recherche prend un certain temps à trouver, mais aussi lorsqu'elle ne trouve pas. Car dans le code il y a une condition donnée par :cs40:, et en calculant ce qu'il reste à chercher on produit un nombre de comptages très conséquent. L'idée de créer un moteur de recherche qui tiendrait la mesure du nombre premier, ceci est l'étape suivante. Pour le moment je vous propose de voir les premiers pas qui je l'espère sont sans faux - pas

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
from math import sqrt
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Suite  à   Nphony_11 : 30 avril 2017
# Programme Nphonic_0a : 1 mai 2017
'''Mise à jour au      : 8 mai 2017'''
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
 
def nombre(n_):
    """Introduction du NOMBRE"""
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        """Recherche d'un élément lié"""
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1 + 1  # :csq1: Racine Carrée NOMBRE
            if sq2 < 3:
                cs20 = cs21 = sq2  # :sq2: R C de :csq1:
                cs30 = cs10
                cs40 = cs20
            else:
                cs20 = cs21 = sq2 - 1
                cs30 = int(sq2 + (sq3 ** 2.5))
                cs40 = int(csq1 - (sq3 ** 2.5))
            w2 = 0
            while 1:
                if csq1 < 4:
                    w10 = 1
                if not corg % cs10:
                    # Décrément de :cs10: à :cs40:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20 \
                        and sq2 > 1:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21 \
                        and cs21 > 1:
                    # Incrément de :cs21: à :cs30:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    if cs10 > cs40:
                        cs10 -= 1
                    if cs21 < cs30:
                        cs21 += 1
                    else:
                        w2 = 1
                    if len(nivbas) == 0 \
                            and w2 == 1:
                        cs20 -= 1
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        """Alignement des multiplicateurs"""
        so2 = nv0 = nv1 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        """Multiplication élémentaire"""
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1 \
                        and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        """Production des multiplicandes"""
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', int(sq1[0]), sq2, sq3)
    print('Nphonic_0a.py En {}'.format(time.time() - d0))
 
uno = 12345678987654321
print('Cosmic', uno)
nombre(uno)

[Invité]

Où plusieurs compteurs/cueilleurs sont étalés à plein vent, la prochaine étape serait de mettre en dictionnaire tous ces gadgets.
Malheureusement pour les plus grands nombres, le comptage est lent à cause des éléments à traiter.
Une fois ce compteur achevé, les types vont être utilisés à des fins de filtrage des actions à mener au niveau de la cueillette

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
"""MusicAToumic En"""
# Programmes  Nphony_0a : 18 avril 2017
# Suite  à    Nphony_11 : 30 avril 2017
# Programmes Nphonic_0a : 1 mai 2017
# Programme Nphonic_11a : 13 mai 2017
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
nivrec = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
 
def nombre(n_):
    """Introduction du NOMBRE"""
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(norg**(1/4))
        sq3 = int(norg**(1/8))
    bi0[0] = 0
    def cobas(c_):
        """Recherche d'un élément lié"""
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_ // c_)
            nivbas.append(c_)
        else:
            # NOMBRE apte à recherche
            csq1 = corg**(1/2)
            if corg == norg:
                sq1[0] = int(csq1)
            cs10 = sq1[0] + 1  # :csq1: Racine Carrée NOMBRE
            if sq2 < 3:
                cs20 = cs21 = sq2  # :sq2: R C de :csq1:
                cs51 = cs30 = cs10
                cs50 = cs40 = cs20
            else:
                cs20 = cs21 = sq2 - 1
                cs51 = cs30 = int(sq2 + (sq3 ** 3))
                cs50 = cs40 = int(csq1 - (sq3 ** 3))
            cs60 = cs61 = cs00 = int((int((csq1 - sq2)//2))**(1/2))
            c1 = c2 = c3 = c4 = c5 = c6 = c7 = 0 # Commun
            s1 = s2 = s3 = s4 = s5 = s6 = s7 = 0 # Absent
            w1 = 0
            while 1:
                w1 += 1
                if csq1 < 4: # Commence Racine :csq1:
                    w10 = 1
                # Section des cueilleurs
                if not corg % cs10 and s1 == 0\
                   and cs10 not in nivrec:
                    # Décrément de :cs10: à :cs40:
                    nivrec.append(cs10)
                    c1 = 1
                if not corg % cs50 and s2 == 0\
                   and cs50 not in nivrec:
                    # Décrément de :cs50: à :cs00:
                    nivrec.append(cs50)
                    c2 = 1
                if not corg % cs51 and s3 == 0\
                   and cs51 not in nivrec:
                    # Incrément de :cs51: à :cs00:
                    nivrec.append(cs51)
                    c3 = 1
                if not corg % cs60 and s4 == 0\
                   and cs60 not in nivrec:
                    # Décrément de :cs60: à :cs30:
                    nivrec.append(cs60)
                    c4 = 1
                if not corg % cs61 and s5 == 0\
                   and cs61 not in nivrec:
                    # Incrément de :cs61: à :cs40:
                    nivrec.append(cs61)
                    c5 = 1
                if not corg % cs21 and cs21 > 1\
                    and s6 == 0 and cs21 not in nivrec:
                    # Incrément de :cs21: à :cs30:
                    nivrec.append(cs21)
                    c6 = 1
                if not corg % cs20 and sq2 > 1\
                    and cs20 not in nivrec:
                    # Décrément de :cs20: à 0
                    nivrec.append(cs20)
                    c7 = 1
                # Section des compteurs
                if w10 == 1: # Clause :csq1<4:
                    cs10 -= 1
                else:
                    cgen = c1+c2+c3+c4+c5+c6+c7
                    sgen = s1+s2+s3+s4+s5+s6+s7
                    if cs10 > cs40 and c1 == 0:
                            cs10 -= 1
                    else: s1 = 1
                    if cs50 > cs00 and c2 == 0:
                        cs50 -=1
                    else: s2 = 1
                    if cs51 < cs00 and c3 == 0:
                        cs51 +=1
                    else: s3 = 1
                    if cs60 > cs30 and c4 == 0:
                        cs60 -=1
                    else: s4 = 1
                    if cs61 < cs40 and c5 == 0:
                        cs61 +=1
                    else: s5 = 1
                    if cs21 < cs30 and c6 == 0:
                        cs21 += 1
                    else: s6 = 1
                    if cs20 > 0 and sgen > 0 \
                       and cgen == 0:
                        cs20 -= 1
                    if cgen > 0 and sgen > 2:
                        nvmx = max(nivrec)
                        nivbas.append(nvmx)
                        nivbas.append(corg // nvmx)
                        break
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        """Alignement des multiplicateurs"""
        so2 = nv0 = nv1 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sub**(1/2))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        """Multiplication élémentaire"""
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1 \
                        and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        """Production des multiplicandes"""
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0], sq2, sq3)
    print('Nphonic_11a.py En {}'.format(time.time() - d0))
 
uno = 3652123456737365212
print('Cosmic', uno)
nombre(uno)
# a**(1./b) racine ou a**.5
# Nombre avec un seul couple commun 365212345677

[Invité]

Bonjour

Pour avancer, ont étés incorporés des compteurs/cueilleurs. Différenciés en étalage en pleine Racine Carrée

Tout un suivit des états trouvés et non trouvés, qui avant de se retrouver sous la forme d'un dictionnaire

Vont venir se présenter ici

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
"""MusicAToumic En"""
# Programmes  Nphony_0a : 18 avril 2017
# Suite  à    Nphony_11 : 30 avril 2017
# Programmes Nphonic_0a : 1 mai 2017
# Programme Nphonic_11a : 13 mai 2017
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
nivrec = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
 
def nombre(n_):
    """Introduction du NOMBRE"""
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(norg**(1/4))
        sq3 = int(norg**(1/8))
    bi0[0] = 0
    def cobas(c_):
        """Recherche d'un élément lié"""
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_ // c_)
            nivbas.append(c_)
        else:
            # NOMBRE apte à recherche
            csq1 = corg**(1/2)
            if corg == norg:
                sq1[0] = int(csq1)
            cs10 = sq1[0] + 1  # :csq1: Racine Carrée NOMBRE
            if sq2 < 3:
                cs20 = cs21 = sq2  # :sq2: R C de :csq1:
                cs51 = cs30 = cs10
                cs50 = cs40 = cs20
            else:
                cs20 = cs21 = sq2 - 1
                cs51 = cs30 = int(sq2 + (sq3 ** 3))
                cs50 = cs40 = int(csq1 - (sq3 ** 3))
            cs60 = cs61 = cs00 = int((int((csq1 - sq2)//2))**(1/2))
            c1 = c2 = c3 = c4 = c5 = c6 = c7 = 0 # Commun
            s1 = s2 = s3 = s4 = s5 = s6 = s7 = 0 # Absent
            w1 = 0
            while 1:
                w1 += 1
                if csq1 < 4: # Commence Racine :csq1:
                    w10 = 1
                # Section des cueilleurs
                if not corg % cs10 and s1 == 0\
                   and cs10 not in nivrec:
                    # Décrément de :cs10: à :cs40:
                    nivrec.append(cs10)
                    c1 = 1
                if not corg % cs50 and s2 == 0\
                   and cs50 not in nivrec:
                    # Décrément de :cs50: à :cs00:
                    nivrec.append(cs50)
                    c2 = 1
                if not corg % cs51 and s3 == 0\
                   and cs51 not in nivrec:
                    # Incrément de :cs51: à :cs00:
                    nivrec.append(cs51)
                    c3 = 1
                if not corg % cs60 and s4 == 0\
                   and cs60 not in nivrec:
                    # Décrément de :cs60: à :cs30:
                    nivrec.append(cs60)
                    c4 = 1
                if not corg % cs61 and s5 == 0\
                   and cs61 not in nivrec:
                    # Incrément de :cs61: à :cs40:
                    nivrec.append(cs61)
                    c5 = 1
                if not corg % cs21 and cs21 > 1\
                    and s6 == 0 and cs21 not in nivrec:
                    # Incrément de :cs21: à :cs30:
                    nivrec.append(cs21)
                    c6 = 1
                if not corg % cs20 and sq2 > 1\
                    and cs20 not in nivrec:
                    # Décrément de :cs20: à 0
                    nivrec.append(cs20)
                    c7 = 1
                # Section des compteurs
                if w10 == 1: # Clause :csq1<4:
                    cs10 -= 1
                else:
                    cgen = c1+c2+c3+c4+c5+c6+c7
                    sgen = s1+s2+s3+s4+s5+s6+s7
                    if cs10 > cs40 and c1 == 0:
                            cs10 -= 1
                    else: s1 = 1
                    if cs50 > cs00 and c2 == 0:
                        cs50 -=1
                    else: s2 = 1
                    if cs51 < cs00 and c3 == 0:
                        cs51 +=1
                    else: s3 = 1
                    if cs60 > cs30 and c4 == 0:
                        cs60 -=1
                    else: s4 = 1
                    if cs61 < cs40 and c5 == 0:
                        cs61 +=1
                    else: s5 = 1
                    if cs21 < cs30 and c6 == 0:
                        cs21 += 1
                    else: s6 = 1
                    if cs20 > 0 and sgen > 0 \
                       and cgen == 0:
                        cs20 -= 1
                    if cgen > 0 and sgen > 2:
                        nvmx = max(nivrec)
                        nivbas.append(nvmx)
                        nivbas.append(corg // nvmx)
                        break
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        """Alignement des multiplicateurs"""
        so2 = nv0 = nv1 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sub**(1/2))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        """Multiplication élémentaire"""
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1 \
                        and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        """Production des multiplicandes"""
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0], sq2, sq3)
    print('Nphonic_11a.py En {}'.format(time.time() - d0))
 
uno = 9130308641843413
print('Cosmic', uno)
nombre(uno)
# a**(1./b) racine ou a**.5
# Nombre avec un seul couple commun 365212345677

Suite auquel va s'appliquer à filtrer la cueillette, en omettant certains compteurs...

[Invité]

Après quelques versions évolutives, pour enfin parvenir à itérer par comparaison à un commun possible le moins "longtemps" possible. Précédemment, une série de points d'itérations mis en place à l'aide des racines carrées. Cette structure de lecteurs / cueilleurs finalisée, et selon quelques paramétrages du code. A plusieurs fonctionnements :

• La sélection du premier commun rencontré. Moins important et plus rapide à itérer
• Le cumul d'un unique commun par section. Permet un plus large choix de multiplicandes
• Le cumul des communs aux préalables premiers. Intègre les tempéraments multiplicateurs

Le cumul des préalables premiers est facile, à condition que le sujet commun ait un de ces types (1, 5)

L'univers composé de la multiplication des tempéraments, est sûrement à matérialiser...

# Programme Nphonic_7cosica : 25 mai 2017 Causant comme une recherche instrumentalisée par le code

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme   Nphonic_2cosic : 14 mai 2017
# Programme   Nphonic_5cosic : 24 mai 2017
# Programme  Nphonic_7cosica : 25 mai 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1;ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
uo5 60432 u25 245 iut 60310
imem typ: 1 ou 5 long 5
itab long 14
1 * 3652123456  typ 1*4
2 * 1826061728  typ 2*2
4 * 913030864  typ 4*4
8 * 456515432  typ 2*2
16 * 228257716  typ 4*4
19 * 192217024  typ 1*4
32 * 114128858  typ 2*2
38 * 96108512  typ 2*2
64 * 57064429  typ 4*1
76 * 48054256  typ 4*4
152 * 24027128  typ 2*2
304 * 12013564  typ 4*4
608 * 6006782  typ 2*2
1216 * 3003391  typ 4*1
Cosmic 3652123456 typ 4 long 14
Nphonic_5cosic.py En 0.19465422630310059
"""
dod0 = time.time()
uno = 9
uo5 = int(uno**.5)
uo6 = uno % 6
u25 = int(uno**.25)
iut = (uo5 - u25)//2
#print('uo5', uo5,'u25', u25, 'iut', iut)
imem = []
itab = []
v = uo5 #:uo5: Racine(uno)
w = x = u25 #:u25: Racine(uo5)
u = 1
y = z = iut
#print('P0: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
while 1:
    #print('P1: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
    if not uno%u and u%6 in (2, 3) \
       and u < 6 and u not in imem:
        imem.append(u)
    if not uno%u and u%6 in (1, 5) \
       and u not in imem: #u = u(+1)
        imem.append(u)
    if (uno//u) % 6 in (1, 5) \
       and u not in imem \
       and not uno%(uno//u):
        imem.append(u)
    #print('u', imem)
    if v > y:
        if not uno%v and v not in imem:
            if v%6 in (1, 5):
                imem.append(v)
            elif v == uo5:
                imem.append(v)
        if (uno//v) % 6 in (1, 5) \
           and v not in imem \
           and not uno%(uno//v):
            imem.append(v)
        #print('v', imem)
    if not uno%x and x%6 in (1, 5) \
       and x not in imem: #x = u25(+1)
        imem.append(x)
    if (uno//x) % 6 in (1, 5) \
       and x not in imem \
       and not uno%(uno//x):
        imem.append(x)
    #print('x', imem)
    if w > u:
        if not uno%w \
           and w%6 in (1, 5) \
           and w not in imem: #w = u25(-1)
            imem.append(w)
        if (uno//w) % 6 in (1, 5) \
           and w not in imem \
           and not uno%(uno//w):
            imem.append(w)
        #print('w', imem)
    if not uno%y \
       and y%6 in (1, 5) \
       and y not in imem: #y = iut(+1)
        imem.append(y)
    if (uno//y) % 6 in (1, 5) \
       and y not in imem \
       and not uno%(uno//y):
        imem.append(y)
    #print('y', imem)
    if z > x:
        if not uno%z \
           and z%6 in (1, 5) \
           and z not in imem: #z = iut(-1)
            imem.append(z)
        if (uno//z) % 6 in (1, 5) \
           and z not in imem \
           and not uno%(uno//z):
            imem.append(z)
        #print('z', imem)
    z -= 1
    v -= 1
    w -= 1
    u += 1
    x += 1
    y += 1
    if u > w and x > z and y > v:
        print('P: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
        break
imem.sort()
itab = copy.copy(imem)
#print('imem typ: 1 ou 5', 'long', len(imem))
print('imem', imem)
ion1 = ion2 = 0
#print('itab1', itab)
while 1:
    ion1 = len(itab)
    for i in imem:
        for y in itab:
            i1 = y*i
            if i1 < uo5 and i1 not in itab \
               and not uno % i1:
                itab.append(i1)
    itab.sort()
    #print('it1', itab)
    ion2 = len(itab)
    if ion1 == ion2:
        break
#print('itab', 'long', len(itab))
d = 0
for i in itab:
    d = uno // i
    ip, dv = i, d
    if ip > dv:
        break
    else:
        print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
 
print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
print('Nphonic_7cosica.py En {}'.format(time.time() - dod0))
 
 
 
 
#nombre(uno)

[Invité]

Les nombres associés donnent du relief à en découdre les mailles de la multiplication

Car si on ne peut pas arrêter le poisson dans le filet (puisqu'étant piégé)
Au contraire, il y a des arêtes dans le filet du poisson (en prévision)

C'est en pleine marinade de la mer que nageraient les multiples, tout comme les nombres les poissons ont plusieurs types de pêche. Bien sûr il faut avoir plongé plusieurs fois dans les profondeurs océanes, pour vivre cette expérience commune au grand public. Enfin que d'entreprendre une réécriture, je propose une excuse


Un jour, une dictée codée, pour que l'expression soit un mode opératoire dans le domaine de la programmation en Python (dans le texte)

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme  Nphonic_9cosica : 3 juin 2017
# Programme       nphysic_0a : 3 juin 2017
# Programme        nphysic_1 : 3 juin 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signe '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NpP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NpP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP
Les démultiplications NpP produisent NC
Mes premiers pas sur sur cette échelle
P: u15171w-14925 x15415z14923 y45263v45262
imem [1, 2, 19, 64, 1216]
1° * 3652123456  typ 1*4 a | NpPip
2° * 1826061728  typ 2*2 a | NpPip
4 * 913030864  typ 4*4 a
8 * 456515432  typ 2*2 a
16 * 228257716  typ 4*4 a
19° * 192217024  typ 1*4 a | NpPip
32 * 114128858  typ 2*2 a_
38 * 96108512  typ 2*2 a_
64 * 57064429  typ 4*1 a | NpPdv
76 * 48054256  typ 4*4 a
152 * 24027128  typ 2*2 a
304 * 12013564  typ 4*4 a
608 * 6006782  typ 2*2 a
1216 * 3003391°  typ 4*1 A*B° | NpPdv
Cosmic 3652123456 typ 4 long 14
Nphonic_7cosica.py En 0.17653870582580566
"""
dod0 = d_d1 = time.time()
# Nombre original :onu:
onu = 456213879
# Copie circonstancielle
uno = onu
u1 = 0
if uno == 0: #:uno=0: Zéro issue
    uno = 1
    u1 = 1
uo5 = int(uno**.5)
uo6 = uno % 6
u25 = int(uno**.25)
iut = ((uo5 - u25)//2)
print('uo5(v):', uo5,'u25(w,x):', u25, 'iut(y,z):', iut)
imem = []
itab = []
v = uo5 #:uo5: Racine(uno)
w = x = u25 #:u25: Racine(uo5)
u = 1
y = z = iut
v_ = w_ = z_ = 0
print('P0: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
if u1 == 0: #Zéro issue
    while 1:
        #print('P1: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
        if not uno%u and u%6 in (2, 3) \
           and u < 6 and u not in imem:
            imem.append(u)
        if v > y - 1 and v_ == 0:
            if not uno%v and v not in imem:
                if v%6 in (1, 5):
                    imem.append(v)
                elif v == uo5:
                    imem.append(v)
            if y%6 in (1, 5) \
               and not uno%y \
               and y not in imem: #y = iut(+1)
                imem.append(y)
            if uo6 in (1, 5) and iut != 0:
                if (uno//v) % 6 in (1, 5) \
                   and v not in imem \
                   and not uno%(uno//v):
                    imem.append(v)
                if (uno//y) % 6 in (1, 5) \
                   and y not in imem \
                   and not uno%(uno//y):
                    imem.append(y)
        else:
            v_ = 1
        if w > u - 1 and w_ == 0:
            if not uno%w \
               and w%6 in (1, 5) \
               and w not in imem: #w = u25(-1)
                imem.append(w)
            if not uno%u and u%6 in (1, 5) \
               and u not in imem: #u = u(+1)
                imem.append(u)
            if uo6 in (1, 5) and iut != 0:
                if (uno//w) % 6 in (1, 5) \
                   and w not in imem \
                   and not uno%(uno//w):
                    imem.append(w)
                if (uno//u) % 6 in (1, 5) \
                   and u not in imem \
                   and not uno%(uno//u):
                    imem.append(u)
        else:
            w_ = 1
        if z > x - 1 and z_ == 0:
            if not uno%z \
               and z%6 in (1, 5) \
               and z not in imem: #z = iut(-1)
                imem.append(z)
            if not uno%x and x%6 in (1, 5) \
               and x not in imem: #x = u25(+1)
                imem.append(x)
            if uo6 in (1, 5) and iut != 0:
                if (uno//z) % 6 in (1, 5) \
                   and z not in imem \
                   and not uno%(uno//z):
                    imem.append(z)
                if (uno//x) % 6 in (1, 5) \
                   and x not in imem \
                   and not uno%(uno//x):
                    imem.append(x)
        else:
            z_ = 1
 
        if v_ == 0:
            v -= 1
            y += 1
        if w_ == 0:
            w -= 1
            u += 1
        if z_ == 0:
            z -= 1
            x += 1
        vwz = v_+ w_ + z_
        if vwz > 2:
            #print('P: u:%sw:%s x:%sz:%s y:%sv:%s'%(u,w,x,z,y,v))
            break
imem.sort()
itab = copy.copy(imem)
print(u1,'imem0', imem)
print('Partime En {}'.format(time.time() - d_d1))
ion1 = ion2 = 0
#print('itab1', itab)
if u1 == 0: #Zéro issue
    while 1:
        ion1 = len(itab)
        for i in imem:
            for y in itab:
                i1 = y*i
                if i1 < uo5 and i1 not in itab \
                   and not uno % i1:
                    itab.append(i1)
        itab.sort()
        #print('it1', itab)
        ion2 = len(itab)
        if ion1 == ion2:
            print('ion1',ion2)
            break
    #print('itab', itab,'long', len(itab))
    d = 0
    for i in itab:
        d = uno // i
        ip, dv = i, d
        if ip < dv or ip == dv: # Déblocage :uno = 2 ou 4:
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
else:
    # Zéro issue :uno;onu:
    print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
 
print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
print('nphysic_1.py En {}'.format(time.time() - dod0))
 
 
 
 
#nombre(onu): Charge zéro
#nombre(uno): Charge unité

[Invité]

Les nombres associés donnent du relief à en découdre les mailles de la multiplication

Pour parvenir à détecter les erreurs d'interprétation du programme "nphysic_1", il a fallut démultiplier le nombre "21"
En essayant avec "nphysic_1", il a pour résultat 1 * 21. Autant dire que pour lui le nombre "21" est un nombre premier

Mais non, une erreur était glissée, à cause du non conditionnement de la variable "iut", qui dans ce cas était inférieure à "u25"
Puis ça m'a permis de visiter le code en suivant une ligne d'analyse bien précise, et parfaire ce complexe qui reste à mes yeux

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme  Nphonic_9cosica : 3 juin 2017
# Programme       nphysic_0a : 3 juin 2017
# Programme       nphysic_2a : 28 juin 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signe '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NpP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NpP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP
Les démultiplications NpP produisent NC
Mes premiers pas sur sur cette échelle
"""
# Fonction :imemap: Nombres Premiers (NP)
"""
uo5(v): 60432 u25(w,x): 245 iut(y,z): 30093
P0: u1w245 x245z30093 y30093v60432
0 imem0 [1, 2, 19]
Partime 1 En 0.06004047393798828
ion1 14
1° * 3652123456  typ 1*4
2° * 1826061728  typ 2*2
4 * 913030864  typ 4*4
8 * 456515432  typ 2*2
16 * 228257716  typ 4*4
19° * 192217024  typ 1*4
32 * 114128858  typ 2*2
38 * 96108512  typ 2*2
64 * 57064429  typ 4*1
76 * 48054256  typ 4*4
152 * 24027128  typ 2*2
"""
# Carré² w = x = 245
"""
304 * 12013564  typ 4*4
608 * 6006782  typ 2*2
1216 * 3003391°  typ 4*1
"""
# Centre y = z = 30093
# Carré v = 60432
"""
Partime 2 En 0.045113325119018555
Cosmic 3652123456 typ 4 long 14
nphysic_1.py En 0.1216895580291748
"""
dod0 = d_d1 = time.time()
def onuno(uno):
    u1 = 0
    if uno == 0: #:uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = int(uno**.5)
    uo6 = uno % 6
    u25 = int(uno**.25)
    iut = ((uo5 - u25)//2)
    print('uo5(v):', uo5,'u25(w,x):', u25, 'iut(y,z):', iut)
    imem = []
    uzem = [0]
    v = uo5 #:uo5: Racine(uno)
    w = x = u25 #:u25: Racine(uo5)
    if iut > u25:
        u = 1
    else:
        u = 2
    y = z = iut
    v_ = w_ = z_ = 0
    # print('P0: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
    if u1 == 0: #Zéro issue
        # print('P1: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
        def imemap(uz):
            """ Les nombres premiers
            Des préalables premiers"""
            if not uno%uz and uz%6 in (1, 3, 5) \
               and uz < 8:
                imem.append(uz)
            i5 = sq5 = int(uz**.5)
            i2 = sq2 = int(uz**.25)
            i0 = (i5 - i2) // 2
            for i in range(i5, i0, -1):
                if not uz%i \
                   and i%6 in (1, 5):
                    break
            else:
                for i in range(i2, i0):
                    if not uz%i \
                   and i%6 in (1, 5):
                        break
                else:
                    for i in range(i2, 0, -1):
                        if not uz%i \
                           and i%6 in (1, 5):
                            if i > 1:
                                break
                            elif uz%6 in (1, 5):
                                imem.append(uz)
        while 1:
            if not uno%u and u%6 in (1, 2, 3) \
               and u < 6 and u not in imem:
                imem.append(u)
            if v > y - 1 and v_ == 0:
                if not uno%v and v not in imem:
                    if v%6 in (1, 5):
                        imemap(v)
                    elif v == uo5:
                        imemap(v)
                if y%6 in (1, 5) \
                   and not uno%y \
                   and y not in imem: #y = iut(+1)
                    imemap(y)
                if uo6 in (1, 5) and iut != 0:
                    if (uno//v) % 6 in (1, 5) \
                       and v not in imem \
                       and not uno%(uno//v):
                        imemap(v)
                    if (uno//y) % 6 in (1, 5) \
                       and y not in imem \
                       and not uno%(uno//y):
                        imemap(y)
            else:
                v_ = 1
            if w > u - 1 and w_ == 0:
                if not uno%w \
                   and w%6 in (1, 5) \
                   and w not in imem: #w = u25(-1)
                    imemap(w)
                if not uno%u and u%6 in (1, 5) \
                   and u not in imem \
                   and u > 1: #u = u(+1)
                    imemap(u)
                if uo6 in (1, 5) and iut != 0:
                    if (uno//w) % 6 in (1, 5) \
                       and w not in imem \
                       and not uno%(uno//w):
                        imemap(w)
                    if (uno//u) % 6 in (1, 5) \
                       and u not in imem \
                       and not uno%(uno//u):
                        imemap(u)
            else:
                w_ = 1
            if z > x - 1 and z_ == 0:
                if not uno%z \
                   and z%6 in (1, 5) \
                   and z not in imem: #z = iut(-1)
                    imemap(z)
                if not uno%x and x%6 in (1, 5) \
                   and x not in imem: #x = u25(+1)
                    imemap(x)
                if uo6 in (1, 5) and iut != 0:
                    if (uno//z) % 6 in (1, 5) \
                       and z not in imem \
                       and not uno%(uno//z):
                        imemap(z)
                    if (uno//x) % 6 in (1, 5) \
                       and x not in imem \
                       and not uno%(uno//x):
                        imemap(x)
            else:
                z_ = 1
            # Blanc
            if v_ == 0:
                v -= 1
                y += 1
            if w_ == 0:
                w -= 1
                u += 1
            if z_ == 0:
                z -= 1
                x += 1
            vwz = v_+ w_ + z_
            if vwz > 2:
                break
    # print('P2: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
    imem.sort()
    itab = copy.copy(imem)
    print('Nombres Premiers :ip:', imem)
    # d_d2 = time.time()
    ion1 = ion2 = 0
    if u1 == 0: #Zéro issue
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y*i
                    if i1 not in itab \
                       and not uno % i1:
                        itab.append(i1)
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:
                break
        # print('Partime 2 En {}'.format(time.time() - d_d2))
        # d_d3 = time.time()
        d = u = n = m = 0
        for i in itab:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv: # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' \
                      % (ip, dv, ip % 6, dv % 6))
        #print('Partime 3 En {}'.format(time.time() - d_d3))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % \
              (uno, onu, uno % 6, onu % 6))
        uno = 0
 
    # print('Partime 2 En {}'.format(time.time() - d_d2))
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_2a.py En {}'.format(time.time() - dod0))
# Nombre original :onu:
onu = 21
onuno(onu)
#nombre(onu): Charge zéro
#nombre(uno): Charge unité

[bistouille]

Salut toumic,
(le comique psychédélique du monde quantique de la musique, ah les musicos sont parfois bien barrés )

Blague à part,

Tu pourrais mettre des commentaires dans ton script ?
Histoire qu'on en comprenne le cheminement, car pas facile de suivre ton raisonnement sans un minimum d'explications.

Ah aussi quelques variables qui servent pas.

Code :

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

1
2
3
4
5
6
splash@splash:~$ pyflakes3 toumic.py 
toumic.py:73: local variable 'uzem' is assigned to but never used
toumic.py:91: local variable 'sq5' is assigned to but never used
toumic.py:92: local variable 'sq2' is assigned to but never used
toumic.py:209: local variable 'm' is assigned to but never used
toumic.py:209: local variable 'n' is assigned to but never used

[Invité]

Salut toumic,
(le comique psychédélique du monde quantique de la musique, ah les musicos sont parfois bien barrés )

Blague à part,

Tu pourrais mettre des commentaires dans ton script ?
Histoire qu'on en comprenne le cheminement, car pas facile de suivre ton raisonnement sans un minimum d'explications.

Ah aussi quelques variables qui servent pas.

Quote bistouille
Après corrections et commentaires sur le vif du programme, un résultat qui sera suivit ultérieurement d'explications sommaires.

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme       nphysic_2a : 28 juin 2017
# Programme        nphysic_3 : 28 juin 2017
# Programme        nphysic_4 : 3 juillet 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = int(uno ** .25)
    iut = ((uo5 - u25) // 2)
    print('uo5(v):', uo5, 'u25(w,x):', u25, 'iut(y,z):', iut)
    # Tableau :imem[ip(NP)]:
    imem = []
    v = uo5  # :uo5: Racine(uno)
    w = x = u25  # :u25: Racine(uo5)
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    y = z = iut  # Entre :uo5: et :u25:
    v_ = w_ = z_ = 0  # Indices des fins (v_ pour v...)
    if u1 == 0:  # Zéro issue
        # Fonction d'appel à condition NP
        def imemap(uz):
            """ Les nombres premiers NP
            Des préalables premiers :uz: déjà '1&5' """
            # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
            if not uno % uz and uz % 6 in (1, 3, 5) \
               and uz < 8:
                imem.append(uz)  # Tableau :imem[ip(NP)]:
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                i0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                q = 0
                for iep in range(sq5, i0, -1):
                    if not uz % iep \
                       and iep % 6 in (1, 5):
                        break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if not uz % o \
                       and o % 6 in (1, 5):
                        break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                           and p % 6 in (1, 5):
                            break
                    q += 1
                else:  # :for: Condition vide, donc.
                    imem.append(uz)
                    # Nombre premier NP
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
               and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            if v > y - 1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    if v % 6 in (1, 5):  # NpP :v: est de type '1&5'
                        imemap(v)  # Appel :imemap: Sortant :v: NpP
                    elif v == uo5:  # Le carré est rencontré
                        imemap(v)
                if y % 6 in (1, 5) \
                   and not uno % y \
                   and y not in imem:  # y = iut(+1)
                    imemap(y)
                # :uo6=uno%6: Aléa type NpP test dv
                # NpPdv = Tableau :imem[dv(NP)]:
                if uo6 in (1, 5) and iut != 0:  # Si oui: Faire
                    if (uno // v) % 6 in (1, 5) \
                       and v not in imem \
                       and not uno % (uno // v):
                        imemap(v)  # Appel :imemap: Sortant :v: NpP
                    if (uno // y) % 6 in (1, 5) \
                       and y not in imem \
                       and not uno % (uno // y):
                        imemap(y)
            else:  # Si non: Indice terminal
                v_ = 1
            if w > u - 1 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                   and w % 6 in (1, 5) \
                   and w not in imem:  # w = u25(-1)
                    imemap(w)  # Appel :imemap: Sortant :w: NpP
                if not uno % u and u % 6 in (1, 5) \
                   and u not in imem \
                   and u > 1:  # u = u(+1)
                    imemap(u)
                # :uo6=uno%6: Aléa type NpP test dv
                # NpPdv = Tableau :imem[dv(NP)]:
                if uo6 in (1, 5) and iut != 0:  # Si oui: Faire
                    if (uno // w) % 6 in (1, 5) \
                       and w not in imem \
                       and not uno % (uno // w):
                        imemap(w)  # Appel :imemap: Sortant :w: NpP
                    if (uno // u) % 6 in (1, 5) \
                       and u not in imem \
                       and not uno % (uno // u):
                        imemap(u)
            else:  # Si non: Indice terminal
                w_ = 1
            if z > x - 1 and z_ == 0:  # Si oui: Faire
                if not uno % z \
                   and z % 6 in (1, 5) \
                   and z not in imem:  # z = iut(-1)
                    imemap(z)
                if not uno % x and x % 6 in (1, 5) \
                   and x not in imem:  # x = u25(+1)
                    imemap(x)
                # :uo6=uno%6: Aléa type NpP test dv
                # NpPdv = Tableau :imem[dv(NP)]:
                if uo6 in (1, 5) and iut != 0:  # Si oui: Faire
                    if (uno // z) % 6 in (1, 5) \
                       and z not in imem \
                       and not uno % (uno // z):
                        imemap(z)  # Appel :imemap: Sortant :z: NpP
                    if (uno // x) % 6 in (1, 5) \
                       and x not in imem \
                       and not uno % (uno // x):
                        imemap(x)
            else:  # Si non: Indice terminal
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 1
                y += 1
            if w_ == 0:
                w -= 1
                u += 1
            if z_ == 0:
                z -= 1
                x += 1
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y * i
                    if i1 not in itab \
                       and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2: # 4- :ion1::ion2: Motif de progression
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_4.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 987654321
onuno(onu)
# nombre(onu): Charge zéro
# nombre(uno): Charge unité

J'ai rencontré un problème avec le nombre initial (12345678994), que j'ai solutionné, en ajoutant çà

Code :

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

if o > 1:

là où il faut. En imitant cet existant

Code :

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

if p > 1:

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme       nphysic_2a : 28 juin 2017
# Programme        nphysic_3 : 28 juin 2017
# Programme       nphysic_4a : 3 juillet 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = int(uno ** .25)
    iut = ((uo5 - u25) // 2)
    print('uo5(v):', uo5, 'u25(w,x):', u25, 'iut(y,z):', iut)
    # Tableau :imem[ip(NP)]:
    imem = []
    v = uo5  # :uo5: Racine(uno)
    w = x = u25  # :u25: Racine(uo5)
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    y = z = iut  # Entre :uo5: et :u25:
    v_ = w_ = z_ = 0  # Indices des fins (v_ pour v...)
    if u1 == 0:  # Zéro issue
        # Fonction d'appel à condition NP
        def imemap(uz):
            """ Les nombres premiers NP
            Des préalables premiers :uz: déjà '1&5' """
            # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
            if not uno % uz and uz % 6 in (1, 3, 5) \
               and uz < 8:
                imem.append(uz)  # Tableau :imem[ip(NP)]:
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                i0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                q = 0
                for iep in range(sq5, i0, -1):
                    if not uz % iep \
                       and iep % 6 in (1, 5):
                        break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                           and o % 6 in (1, 5):
                            break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                           and p % 6 in (1, 5):
                            break
                    q += 1
                else:  # :for: Condition vide, donc.
                    imem.append(uz)
                    # Nombre premier NP
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
               and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            if v > y - 1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    if v % 6 in (1, 5):  # NpP :v: est de type '1&5'
                        imemap(v)  # Appel :imemap: Sortant :v: NpP
                    elif v == uo5:  # Le carré est rencontré
                        imemap(v)
                if y % 6 in (1, 5) \
                   and not uno % y \
                   and y not in imem:  # y = iut(+1)
                    imemap(y)
                # :uo6=uno%6: Aléa type NpP test dv
                # NpPdv = Tableau :imem[dv(NP)]:
                if uo6 in (1, 5) and iut != 0:  # Si oui: Faire
                    if (uno // v) % 6 in (1, 5) \
                       and v not in imem \
                       and not uno % (uno // v):
                        imemap(v)  # Appel :imemap: Sortant :v: NpP
                    if (uno // y) % 6 in (1, 5) \
                       and y not in imem \
                       and not uno % (uno // y):
                        imemap(y)
            else:  # Si non: Indice terminal
                v_ = 1
            if w > u - 1 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                   and w % 6 in (1, 5) \
                   and w not in imem:  # w = u25(-1)
                    imemap(w)  # Appel :imemap: Sortant :w: NpP
                if not uno % u and u % 6 in (1, 5) \
                   and u not in imem \
                   and u > 1:  # u = u(+1)
                    imemap(u)
                # :uo6=uno%6: Aléa type NpP test dv
                # NpPdv = Tableau :imem[dv(NP)]:
                if uo6 in (1, 5) and iut != 0:  # Si oui: Faire
                    if (uno // w) % 6 in (1, 5) \
                       and w not in imem \
                       and not uno % (uno // w):
                        imemap(w)  # Appel :imemap: Sortant :w: NpP
                    if (uno // u) % 6 in (1, 5) \
                       and u not in imem \
                       and not uno % (uno // u):
                        imemap(u)
            else:  # Si non: Indice terminal
                w_ = 1
            if z > x - 1 and z_ == 0:  # Si oui: Faire
                if not uno % z \
                   and z % 6 in (1, 5) \
                   and z not in imem:  # z = iut(-1)
                    imemap(z)
                if not uno % x and x % 6 in (1, 5) \
                   and x not in imem:  # x = u25(+1)
                    imemap(x)
                # :uo6=uno%6: Aléa type NpP test dv
                # NpPdv = Tableau :imem[dv(NP)]:
                if uo6 in (1, 5) and iut != 0:  # Si oui: Faire
                    if (uno // z) % 6 in (1, 5) \
                       and z not in imem \
                       and not uno % (uno // z):
                        imemap(z)  # Appel :imemap: Sortant :z: NpP
                    if (uno // x) % 6 in (1, 5) \
                       and x not in imem \
                       and not uno % (uno // x):
                        imemap(x)
            else:  # Si non: Indice terminal
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 1
                y += 1
            if w_ == 0:
                w -= 1
                u += 1
            if z_ == 0:
                z -= 1
                x += 1
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y * i
                    if i1 not in itab \
                       and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2: # 4- :ion1::ion2: Motif de progression
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_4a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 365212345677
onuno(onu)
# nombre(onu): Charge zéro
# nombre(uno): Charge unité

[bistouille]

Merci

[Invité]

Bonsoir

Nombre Premier Harmonique

La rapidité d’exécution est nécessaire au déploiement des grands nombres, il est subtil de croire que le traitement aide à un gain de temps. On s’en aperçoit lorsqu’on fait évoluer l’algorithme de différentes façons, avec un seul ordinateur et IDLE Python. Si le conditionnement est bien réalisé, il gagne du temps. Dans l’ensemble le code se doit d’être clair et précis, mais connaissant mes astuces secrètes... Premiers pas aidant, j’évolue en apprenant à coder correctement afin de me faciliter dans les tâches à venir. Et cette mouture en cours est un résultat grossier des points des lectures, celles qui cherchent les sous-multiples aux types (1&5). S’il y a plusieurs lecteurs, il y a une itération sur différents points, étant plus rapide par cette réunion. Je disais des grossièretés au sujet de ces points, car il peut y en avoir d’avantage tout en révisant leurs dispositions.

Les points de lecture seront paramétrés en fonction du type lié au nombre initial, avec lequel s’effectuent les recherches des multiples communs. Comme le fait un ancien code lorsqu’il a trouvé un premier commun, il évalue les sous-multiples. Par expérience, je sais que ce dernier est plus rapide que cette dernière mouture de recherche (des nombres premiers au milieu des sous-multiples). Je préfère cette dernière même si elle est plus lente, car avec elle (ou pas) on peut affiner les lecteurs / cueilleurs. Varier les valeurs des points, afin qu’aux types (2&3&4&0) puisse s’effectuer un autre genre de recherche. Où le type du grand nombre est (2), il est logique de comprendre que la quantité des communs est importante. Et qu’il est fort probable de rencontrer à un niveau inférieur (en quantité de chiffres dans le nombre), un sous-multiple commun proche de la racine carrée. Le commun étant moins important que le grand nombre initial, les opérations sont donc, plus courtes.

Cibler les points c’est bien, ce qui n’est pas mon point fort, lorsqu’il s’agit des nombres premiers.

Il y a des exemples de nombres-types (1&5), avec un seul sous-multiple. Parmi les exemples, le sous-multiple était (2), ou alors un autre unique commun. Ce qui par cette définition incomprise, s’en déduit à définir des nombres communs aléatoires. Dont je ne peux pas donner avec précision un emplacement, autrement qu’en lecture séquentielle. Il va de soit que ma tâche actuelle la plus importante est de comprendre plus à fond, la composition des sous-multiples entiers et décimaux. Afin de mesurer les emplacements habituels au rapport de la racine carrée, et d’obtenir une forme de lecture adaptée.

Mais là, j’ai encore du travail et de l’étude pour apprendre à maitriser les réalités de la racine carrée. Éléments d’apprentissages par l’expérience, qu’elle soit de moi ou de vous.

[Invité]

Le script précédent a de nombreuses lignes de code afin de fluidifier la recherche des nombres premiers sous-multiples d'un nombre entier.
Ce programme a un tableau qui réunit les nombres premiers allant de 2 à 227, ce qui signifie que la recherche des sous-multiples est limitée.
Et son avantage est qu'il fait gagner du temps, notamment celui de la recherche des nombres premiers, ce qui est intéressant pour les grands nombres.

L'avantage offert par cette démonstration est évident, lorsqu'on parle de l'organisation des nombres multiples communs.
Pour moi c'est une découverte essentielle, et une preuve du sérieux de mes recherches en gammologie numérique (dans le sens du nombre).

Voici le script qui prouve tout ce que j'avance :

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
""" Ce script démontre l'utilisation des nombres premiers,
afin de produire les nombres communs du 'nombre_entier'.
Ceci n'est pas un résultat exhaustif, car il se limite à l'ensemble
du tableau 'premiers', dont le maximum étant 227.
"""
import time
import copy
t = time.time()
premiers = [
    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
    ]   # Liste incomplète des nombres premiers
premiers_communs = []
nombre_entier = 123456
racine_carree = int(nombre_entier **.5)
for p in premiers:  # Les éléments du tableau
    if p <= racine_carree:  # La limite de la recherche
        if (nombre_entier / p).is_integer():
            premiers_communs.append(p)
    else : break
copie_ip = []
copie_ip = copy.copy(premiers_communs)
copie_ip.append(1)     # Utilisé pour les premiers termes
while 1:    # Production des multiples communs
    longueur1 = len(copie_ip)
    for c in premiers_communs:
        for o in copie_ip:
            co = int(c * o)
            if co <= racine_carree \
               and not nombre_entier % co and co not in copie_ip:
                copie_ip.append(co)
    longueur2 = len(copie_ip)
    if longueur1 == longueur2: break
copie_ip.sort()
print('ip', copie_ip)
print('nphermier1. En:{}'.format(time.time()-t))

Et si vous manquez de nombres premiers, complétez le tableau avec ce que ceci produira :

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
import time
t = time.time()
p0 = [2, 3, 5]
n0 = 9999999999
sq = int(n0**.5)
print('sq', sq)
for p1 in range(7, sq + 1, 6):
    p5 = p1 + 4
    pp1 = pp5 = 0
    for p in p0:
        if not p1 % p:
            pp1 = 1
        if not p5 % p:
            pp5 = 1
    if pp1 == 0:
        p0.append(p1)
    if pp5 == 0:
        p0.append(p5)
 
print(p0)
print(time.time()-t)

[Invité]

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme       nphysic_4a : 3 juillet 2017
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)
    # print('uo5(v):', uo5, 'u25(w,x):', u25, 'iut(y,z):', iut)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if int(sut % 6) == 1:
            s00.append(sut)
            s00.append(sut + 4)
        else:
            s00.append(sut + 2)
            s00.append(sut)
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if int(sut % 6) == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                    # :s00[0]: = type 1
                    # :s00[1]: = nombre type 1
                    # :s00[2]: = nombre type 5
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                    # :s00[0]: = type 5
                    # :s00[1]: = nombre type 1
                    # :s00[2]: = nombre type 5
                break
 
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if int(so5 % 6) == 1:
            s01.append(so5)
            s01.append(so5 + 4)
            # :s01[0]: = type 1
            # :s01[1]: = nombre type 1
            # :s01[2]: = nombre type 5
        else:
            s01.append(so5 + 2)
            s01.append(so5)
            # :s01[0]: = type 5
            # :s01[1]: = nombre type 1
            # :s01[2]: = nombre type 5
    else:
        while 1:
            so5 += 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if int(so5 % 6) == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 + 2)
                    s01.append(so5)
                break
 
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if int(s25 % 6) == 1:
            s02.append(s25)
            s02.append(s25 + 4)
            # :s02[0]: = type 1
            # :s02[1]: = nombre type 1
            # :s02[2]: = nombre type 5
        else:
            s02.append(s25 + 2)
            s02.append(s25)
            # :s02[0]: = type 5
            # :s02[1]: = nombre type 1
    else:
        while 1:
            s25 -= 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if int(s25 % 6) == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 + 2)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]
    # print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des fins (v_ pour v...)
    if u1 == 0:  # Zéro issue
        # Fonction d'appel à condition NP
        def imemap(uz):
            """ Les nombres premiers NP
            Des préalables premiers :uz: déjà '1&5' """
            # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
            if not uno % uz and uz % 6 in (1, 3, 5) \
               and uz < 8:
                imem.append(uz)  # Tableau :imem[ip(NP)]:
            else:
                # print(uz, 'mim2', imem)
                # :rim: Reconstruction à chaque tour
                rim = [mm for mm in imem if mm > 1]
                for rr in rim:
                    if not uz % rr:
                        r0 = 1
                        break
                else:
                    # Rapports des racines carrées :uz:
                    sq5 = int(uz ** .5)
                    sq2 = int(uz ** .25)
                    i0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                    # :iep: Ordonnée de carré à carré²
                    # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                    q = 0
                    for iep in range(sq5, i0, -1):
                        if not uz % iep \
                           and iep % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // iep) \
                           and (uz // iep) % 6 in (1, 5):
                            r0 = 1
                            break
                        o = sq2 + q  # Ordonnée de carré² incrémenté
                        if o > 1:
                            if not uz % o \
                               and o % 6 in (1, 5):
                                r0 = 1
                                break
                            if not uz % (uz // o) \
                               and (uz // o) % 6 in (1, 5):
                                r0 = 1
                                break
                        p = sq2 - q  # Ordonnée de carré² décrémenté
                        if p > 1:
                            if not uz % p \
                               and p % 6 in (1, 5):
                                r0 = 1
                                break
                            if not uz % (uz // p) \
                               and (uz // p) % 6 in (1, 5):
                                r0 = 1
                                break
                        q += 1
                    else:
                        r0 = 0
                if r0 == 0:  # :for: Condition vide, donc.
                    imem.append(uz)
                    # Nombre premier NP
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
               and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y::sq5|sut:
            if v >= y and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Appel :imemap: Sortant :v: NpP
                    if v == uo5:  # Le carré est rencontré
                        imemap(v)
                if not uno % v5 and v5 not in imem:
                    imemap(v5)  # Appel :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Le carré est rencontré
                        imemap(v5)
                if not uno % y \
                   and y not in imem:  # y = iut(+1)
                    imemap(y)
                if not uno % y5 \
                   and y5 not in imem:  # y5 = iut(+1)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
 
            # :w >= u::s25|u:
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                   and w not in imem:  # w = u25(-1)
                    imemap(w)  # Appel :imemap: Sortant :w: NpP
                if not uno % u and u not in imem \
                   and u % 6 in (1, 5) \
                   and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 \
                   and w5 not in imem:  # w5 = u25(-1)
                    imemap(w5)  # Appel :imemap: Sortant :w5: NpP
            else:  # Si non: Indice terminal
                w_ = 1
 
            # :z >= x::sut|s25:
            if z >= x and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                   and z not in imem:  # z = iut(-1)
                    imemap(z)
                if not uno % x \
                   and x not in imem:  # x = u25(+1)
                    imemap(x)
                if not uno % z5 \
                   and z5 not in imem:  # z5 = iut(-1)
                    imemap(z5)
                if not uno % x5 \
                   and x5 not in imem:  # x5 = u25(+1)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y * i
                    if i1 not in itab \
                       and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_7a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 2468135790
onuno(onu)
# nombre(onu): Charge zéro
# nombre(uno): Charge unité

[Invité]

Bonjour, voici la dernière d'autant plus véloce qu'intéressante


Choisissez nphysic_8a.py, bien sûr

Erreurs avec les petits nombres, en voie de correction

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
# Programme        nphysic_8 : 31 juillet 2017
# Programme       nphysic_8a : 15 août 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points de récupération 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)  # print('uo5(v):', uo5, 'iut(y,z):', iut, 'u25(w,x):', u25)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if s00[0] == 1:
            s00.append(sut)
            s00.append(sut + 4)
            # :s00[0]: = type état 1
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
        else:
            s00.append(sut + 2)
            s00.append(sut)
            # :s00[0]: = type état 5
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if s00[0] == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                break
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if s01[0] == 1:
            s01.append(so5)
            s01.append(so5 + 4)
        else:
            s01.append(so5 + 2)
            s01.append(so5)
    else:
        while 1:
            so5 -= 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if s01[0] == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 - 4)
                    s01.append(so5)
                break
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if s02[0] == 1:
            s02.append(s25)
            s02.append(s25 + 4)
        else:
            s02.append(s25 + 2)
            s02.append(s25)
    else:
        while 1:
            s25 += 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if s02[0] == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 + 2)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]  #
    print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Généralités repèrées
    v1 = s01[1] - int(s02[1] ** 1.5)
    z1 = s00[1] - int(s02[1] ** 1.5)
    if v1 % 6 != 1:
        if v1 % 6 == 0:
            v1 += 1
        else:
            v2 = v1 % 6 - 1
            v1 -= v2
    if z1 % 6 != 1:
        if z1 % 6 == 0:
            z1 += 1
        else:
            v2 = v1 % 6 - 1
            z1 -= v2
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
    # Fonction d'appel à condition NP
    def imemap(uz):
        # print('uz', uz)
        """ Les nombres premiers NP
        Des préalables premiers :uz: déjà '1&5' """
        # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
        if not uno % uz and uz % 6 in (1, 3, 5) \
                and uz < 8:
            imem.append(uz)  # Tableau :imem[ip(NP)]:
        else:
            # :rim: Reconstruction à chaque tour
            rim = [mm for mm in imem if mm > 1]
            for rr in rim:
                if not uz % rr:
                    r0 = 1
                    break
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                ind0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                q = 0
                for iep in range(sq5, ind0, -1):
                    if not uz % iep \
                            and iep % 6 in (1, 5):
                        r0 = 1
                        break
                    if not uz % (uz // iep) \
                            and (uz // iep) % 6 in (1, 5):
                        r0 = 1
                        break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                                and o % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // o) \
                                and (uz // o) % 6 in (1, 5):
                            r0 = 1
                            break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                                and p % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // p) \
                                and (uz // p) % 6 in (1, 5):
                            r0 = 1
                            break
                    q += 1
                else:
                    r0 = 0
            if r0 == 0:  # :for: Condition vide, donc.
                imem.append(uz)
                # Nombre premier NP
    if u1 == 0:  # Zéro issue
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
                    and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y: :sq5|sut: Environnement
            if v > v1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Envoi :imemap: Sortant :v: NpP
                    if v == uo5:  # Carré rencontré Type 1
                        imemap(v)
                if not uno % v5 and v5 not in imem \
                        and v5 > 1:
                    imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Carré rencontré Type 5
                        imemap(v5)
                if not uno % y \
                        and y not in imem:  # y = iut(+6)
                    imemap(y)
                if not uno % y5 \
                        and y5 not in imem:  # y5 = iut(+6)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
            # :w >= u: :s25|u: Environnement
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                        and w not in imem:  # w = u25(-6)
                    imemap(w)
                if not uno % u and u not in imem \
                        and u % 6 in (1, 5) \
                        and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 and w5 > 1 \
                        and w5 not in imem:  # w5 = u25(-6)
                    imemap(w5)
            else:  # Si non: Indice terminal
                w_ = 1
            # :z >= x: :sut|s25: Environnement
            if z > z1 and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                        and z not in imem:  # z = iut(-6)
                    imemap(z)
                if not uno % x \
                        and x not in imem:  # x = u25(+6)
                    imemap(x)
                if not uno % z5 \
                        and z5 not in imem:  # z5 = iut(-6)
                    imemap(z5)
                if not uno % x5 \
                        and x5 not in imem:  # x5 = u25(+6)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i0 = y * i
                    if i0 > s01[1]:
                        i1 = uno // i0
                        if i1 not in imem:
                            imemap(i1)
                    else:
                        i1 = i0
                    if i1 not in itab \
                            and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                imem = copy.copy(itab)
                print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
        uo6 = uno % 6
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_8a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 98
onuno(onu)

[Invité]

Bonjour, voici la dernière d'autant plus véloce qu'intéressante


Choisissez nphysic_8a.py, bien sûr

Erreurs avec les petits nombres, en voie de correction

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
# Programme        nphysic_8 : 31 juillet 2017
# Programme       nphysic_8a : 15 août 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points de récupération 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)  # print('uo5(v):', uo5, 'iut(y,z):', iut, 'u25(w,x):', u25)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if s00[0] == 1:
            s00.append(sut)
            s00.append(sut + 4)
            # :s00[0]: = type état 1
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
        else:
            s00.append(sut + 2)
            s00.append(sut)
            # :s00[0]: = type état 5
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if s00[0] == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                break
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if s01[0] == 1:
            s01.append(so5)
            s01.append(so5 + 4)
        else:
            s01.append(so5 + 2)
            s01.append(so5)
    else:
        while 1:
            so5 -= 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if s01[0] == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 - 4)
                    s01.append(so5)
                break
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if s02[0] == 1:
            s02.append(s25)
            s02.append(s25 + 4)
        else:
            s02.append(s25 + 2)
            s02.append(s25)
    else:
        while 1:
            s25 += 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if s02[0] == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 + 2)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]  #
    print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Généralités repèrées
    v1 = s01[1] - int(s02[1] ** 1.5)
    z1 = s00[1] - int(s02[1] ** 1.5)
    if v1 % 6 != 1:
        if v1 % 6 == 0:
            v1 += 1
        else:
            v2 = v1 % 6 - 1
            v1 -= v2
    if z1 % 6 != 1:
        if z1 % 6 == 0:
            z1 += 1
        else:
            v2 = v1 % 6 - 1
            z1 -= v2
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
    # Fonction d'appel à condition NP
    def imemap(uz):
        # print('uz', uz)
        """ Les nombres premiers NP
        Des préalables premiers :uz: déjà '1&5' """
        # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
        if not uno % uz and uz % 6 in (1, 3, 5) \
                and uz < 8:
            imem.append(uz)  # Tableau :imem[ip(NP)]:
        else:
            # :rim: Reconstruction à chaque tour
            rim = [mm for mm in imem if mm > 1]
            for rr in rim:
                if not uz % rr:
                    r0 = 1
                    break
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                ind0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                q = 0
                for iep in range(sq5, ind0, -1):
                    if not uz % iep \
                            and iep % 6 in (1, 5):
                        r0 = 1
                        break
                    if not uz % (uz // iep) \
                            and (uz // iep) % 6 in (1, 5):
                        r0 = 1
                        break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                                and o % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // o) \
                                and (uz // o) % 6 in (1, 5):
                            r0 = 1
                            break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                                and p % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // p) \
                                and (uz // p) % 6 in (1, 5):
                            r0 = 1
                            break
                    q += 1
                else:
                    r0 = 0
            if r0 == 0:  # :for: Condition vide, donc.
                imem.append(uz)
                # Nombre premier NP
    if u1 == 0:  # Zéro issue
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
                    and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y: :sq5|sut: Environnement
            if v > v1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Envoi :imemap: Sortant :v: NpP
                    if v == uo5:  # Carré rencontré Type 1
                        imemap(v)
                if not uno % v5 and v5 not in imem \
                        and v5 > 1:
                    imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Carré rencontré Type 5
                        imemap(v5)
                if not uno % y \
                        and y not in imem:  # y = iut(+6)
                    imemap(y)
                if not uno % y5 \
                        and y5 not in imem:  # y5 = iut(+6)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
            # :w >= u: :s25|u: Environnement
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                        and w not in imem:  # w = u25(-6)
                    imemap(w)
                if not uno % u and u not in imem \
                        and u % 6 in (1, 5) \
                        and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 and w5 > 1 \
                        and w5 not in imem:  # w5 = u25(-6)
                    imemap(w5)
            else:  # Si non: Indice terminal
                w_ = 1
            # :z >= x: :sut|s25: Environnement
            if z > z1 and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                        and z not in imem:  # z = iut(-6)
                    imemap(z)
                if not uno % x \
                        and x not in imem:  # x = u25(+6)
                    imemap(x)
                if not uno % z5 \
                        and z5 not in imem:  # z5 = iut(-6)
                    imemap(z5)
                if not uno % x5 \
                        and x5 not in imem:  # x5 = u25(+6)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i0 = y * i
                    if i0 > s01[1]:
                        i1 = uno // i0
                        if i1 not in imem:
                            imemap(i1)
                    else:
                        i1 = i0
                    if i1 not in itab \
                            and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                imem = copy.copy(itab)
                print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
        uo6 = uno % 6
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_8a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 98
onuno(onu)

Au juste, il n' a eu qu'à adapter cette petite logique

Code :

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

1
2
3
4
5
6
7
# Généralités repèrées
    if s01[1] < int(s02[1] ** 1.5):
        v1 = y
        z1 = x
    else:
        v1 = s01[1] - int(s02[1] ** 1.5)
        z1 = s00[1] - int(s02[1] ** 1.5)

Pour la totale

nphysic_8a.py

Ce qu'il y a à la suite de cette expérience la multiplication des deux tables (imem et itab), il y a une recherche basée sur les multiples, et non pas à l'aide des itérations (+6, -6).
Cet élément donne un indice visant à réduire le taux des itérations à l'aide de la multiplication (pour un gain de temps), et un autre point de vue

Que des promesses .... Qu'elle erreur !

[Invité]

Au juste, il n' a eu qu'à adapter cette petite logique

Code :

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

# Généralités repèrées

Pour la totale

nphysic_7a.py

Ce qu'il y a à la suite de cette expérience la multiplication des deux tables (imem et itab), il y a une recherche basée sur les multiples, et non pas à l'aide des itérations (+6, -6).
Cet élément donne un indice visant à réduire le taux des itérations à l'aide de la multiplication (pour un gain de temps), et un autre point de vue

Que des promesses .... Qu'elle erreur !

Quelle belle erreur pourrait-on dire, ainsi que, quel enseignement rapporté !.
Si la version "_7a.py" est stable, "_8a.py" est minoritaire.

La minorité démontre la capacité des nombres premiers à la reproduction, qui pour le cas s'est formée avec les uniques nombres premiers dont elle disposait. Et, elle a produit son cycle multiplicatif, elle enseigne sur un ensemble cyclique composé par chaque nombre premier. Mais ce qu'elle ne produit pas est bien la totalité des nombres premiers recherchés, seulement à cause d'un espace de mesure réduit.

La logique de "_8a.py" est d'éviter l'itération en temps réel, en privilégiant la multiplication des nombres premiers. Pour répondre finalement à cette requête, la version "_9a.py" finalise la série des nombres premiers à grands coups d'algorithmes . Contrairement la version 9 est plus lente que la 7.

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
# Programme        nphysic_8 : 31 juillet 2017
# Programme       nphysic_9a : 18 août 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points de récupération 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)  # print('uo5(v):', uo5, 'iut(y,z):', iut, 'u25(w,x):', u25)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if s00[0] == 1:
            s00.append(sut)
            s00.append(sut + 4)
            # :s00[0]: = type état 1
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
        else:
            s00.append(sut + 2)
            s00.append(sut)
            # :s00[0]: = type état 5
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if s00[0] == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                break
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if s01[0] == 1:
            s01.append(so5)
            s01.append(so5 + 4)
        else:
            s01.append(so5 + 2)
            s01.append(so5)
    else:
        while 1:
            so5 -= 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if s01[0] == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 - 4)
                    s01.append(so5)
                break
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if s02[0] == 1:
            s02.append(s25)
            s02.append(s25 + 4)
        else:
            s02.append(s25 - 4)
            s02.append(s25)
    else:
        while 1:
            s25 += 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if s02[0] == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 - 4)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]  # print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Généralités repèrées
    if s01[1] < int(s02[1] ** 1.5):
        v1 = y
        z1 = x
    else:
        v1 = s01[1] - int(s02[1] ** 1.5)
        z1 = s00[1] - int(s02[1] ** 1.5)
    if v1 % 6 != 1:
        if v1 % 6 == 0:
            v1 += 1
        else:
            v2 = v1 % 6 - 1
            v1 -= v2
    if z1 % 6 != 1:
        if z1 % 6 == 0:
            z1 += 1
        else:
            v2 = z1 % 6 - 1
            z1 -= v2
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
    # Fonction d'appel à condition NP
    itabtb = []
    itabmx = [0]
    itabqt = [0]
    itabqt[0] = 0
    def imemap(uz):
        """ Les nombres premiers NP
        Des préalables premiers :uz: déjà '1&5' """
        # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
        if not uno % uz and uz % 6 in (1, 3, 5) \
                and uz < 8:
            imem.append(uz)  # Tableau :imem[ip(NP)]:
        else:
            # :rim: Reconstruction à chaque tour
            rim = [mm for mm in imem if mm > 1]
            for rr in rim:
                if not uz % rr:
                    r0 = 1
                    break
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                ind0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                q = 0
                for iep in range(sq5, ind0, -1):
                    if not uz % iep \
                            and iep % 6 in (1, 5):
                        r0 = 1
                        if itabqt[0] == 1:
                            itabtb.append(iep)
                        else:
                            break
                    if not uz % (uz // iep) \
                            and (uz // iep) % 6 in (1, 5):
                        r0 = 1
                        if itabqt[0] == 1:
                            itabtb.append(uz // iep)
                        else:
                            break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                                and o % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // o) \
                                and (uz // o) % 6 in (1, 5):
                            r0 = 1
                            break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                                and p % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // p) \
                                and (uz // p) % 6 in (1, 5):
                            r0 = 1
                            break
                    q += 1
                else:
                    r0 = 0
            if r0 == 0:  # :for: Condition vide, donc.
                if itabqt[0] == 0:
                    imem.append(uz)
                    # Nombre premier NP
    if u1 == 0:  # Zéro issue
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
                    and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y: :sq5|sut: Environnement
            if v > v1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Envoi :imemap: Sortant :v: NpP
                    if v == uo5:  # Carré rencontré Type 1
                        imemap(v)
                if not uno % v5 \
                        and v5 not in imem:
                    imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Carré rencontré Type 5
                        imemap(v5)
                if not uno % y \
                        and y not in imem:  # y = iut(+6)
                    imemap(y)
                if not uno % y5 \
                        and y5 not in imem:  # y5 = iut(+6)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
            # :w >= u: :s25|u: Environnement
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w and w not in imem:  # w = u25(-6)
                    imemap(w)
                if not uno % u and u not in imem \
                        and u % 6 in (1, 5) \
                        and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 and w5 > 1 \
                        and w5 not in imem:  # w5 = u25(-6)
                    imemap(w5)
            else:  # Si non: Indice terminal
                w_ = 1
            # :z >= x: :sut|s25: Environnement
            if z > z1 and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                        and z not in imem:  # z = iut(-6)
                    imemap(z)
                if not uno % x \
                        and x not in imem:  # x = u25(+6)
                    imemap(x)
                if not uno % z5 and z5 not in imem \
                        and z5 > 1:  # z5 = iut(-6)
                    imemap(z5)
                if not uno % x5 \
                        and x5 not in imem:  # x5 = u25(+6)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y * i
                    if i1 not in itab and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                itabmx[0] = uno // max(itab)
                it01 = len(itabtb)
                if itabmx[0] > uo5:
                    itabqt[0] = 1
                    imemap(itabmx[0])
                itabqt[0] = 0
                for it in itabtb:
                    imemap(it)
                it02 = len(itabtb)
                if it01 == it02:
                    break
        print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
        uo6 = uno % 6
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_9a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
# 365212345636521
onu = 365212345636521
onuno(onu)

En tous les cas, une belle aventure

#

[Invité]

N physic 8a…
Étape élémentaire A&Z
La solution la plus abordable est, de diviser le nombre entier par une série de diviseurs allant de la racine carré à 1. Ainsi, quand le quotient est également un nombre entier, ce dernier est alors un multiple commun. Si les divisions n’ont pas données les entiers, le diviseur 1 termine la recherche. Et, il s’agit d’un nombre premier.
Étape typique 1&5
Les communs s’accouplent pour produire un nombre unique, chaque élément couplé est distribué de part et d’autre de la racine carrée. En mesurant les teneurs, on produit les mêmes communs à moindre quantité. La division a un reste à minimum zéro, quand le diviseur est six se produit une assimilation numérale. Elle est visible, pour le quotient sur sa partie décimale. Et généralement du côté du reste, il y a les types (1, 2, 3, 4, 5, 0). Cette deuxième étape effectue la même séquence que celle de l’étape élémentaire, du ci-dessus. Mais au lieu de cueillir les communs de A à Z, et dès que le commun de type (1 & 5) est trouvé. Se scénarise, sur cet élément commun au couple de bas niveau et sur son associé de haut niveau, la série élémentaire de A à Z.
Étape commune IP&DV
L’étape précédente donne le premier couple dont le bas niveau est de l’un des types (1&5), et afin de réduire le nombre des itérations, commencer par les petits nombres est judicieux. L’étape de A à Z développe le tempérament de six sur une recherche de sous-multiple, moins important est le nombre en question et plus rapide est son cycle. Où le sous-multiple au niveau bas du couple est moindre, celui du niveau haut est important. Ce couple dont l’IP est typé (1&5), il s’unit à son DV ayant aussi un type. La multiplication IP par DV produit le nombre entier, l’étape de A à Z donne les communs liés à chaque élément, IP et DV couplés. Il est logique d’y voir qu’en multipliant les communs liés à IP avec ceux de DV, se produisent tous les multiples communs en relation.
Étape couplage IP|1&5|&DV|1&5|
L’étape précédente comprend une occurrence IP de type (1&5), qui a peu de chance d’avoir de nombreux sous-multiples de type (1&5). D’une à cause de la petitesse de son importance, et de deux à cause du fait qu’il puisse être un nombre premier et donc pas de sous-multiple commun. La situation s’inverse en ayant trouvé le premier DV de type (1&5), car en tant qu’élément de couple de haut niveau. À moins qu’il soit un nombre premier, ou autrement il a plusieurs sous-multiples communs aux types avantageux (1&5). Lorsqu’on connaît la nature de leurs tempéraments multiplicatifs, on a un groupe d’agents en un seul tenant. Étant donné la rareté des nombres premiers communs, liés à une unité et ayant une moindre portance itérative. Ce qui s’avère être une bonne solution, d’une part pour le temps d’exécution, ainsi que d’être un bon objectif.
Étape finale 1
L’épisode des itérations est intéressant, selon son aiguillage gérable en fonction des besoins. Les grands nombres ont de vastes champs de recherche (A&Z), sur lesquels s’organisent des points d’itérations. Le nombre de points étant réduit, leurs emplacements sont liés aux états des recherches par l’itération. Les couples de bas niveau sont à la portée de la racine carrée, et ceux du niveau haut sont proche du couple à l’unisson de un et du nombre entier…
_

Ce qui peut être pourrait donner ce code

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
# Programme       nphysic_9a : 18 août 2017
# Programme      nphysic_10a : 19 août 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points de récupération 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)  # print('uo5(v):', uo5, 'iut(y,z):', iut, 'u25(w,x):', u25)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if s00[0] == 1:
            s00.append(sut)
            s00.append(sut + 4)
            # :s00[0]: = type état 1
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
        else:
            s00.append(sut + 2)
            s00.append(sut)
            # :s00[0]: = type état 5
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if s00[0] == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                break
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if s01[0] == 1:
            s01.append(so5)
            s01.append(so5 + 4)
        else:
            s01.append(so5 + 2)
            s01.append(so5)
    else:
        while 1:
            so5 -= 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if s01[0] == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 - 4)
                    s01.append(so5)
                break
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if s02[0] == 1:
            s02.append(s25)
            s02.append(s25 + 4)
        else:
            s02.append(s25 - 4)
            s02.append(s25)
    else:
        while 1:
            s25 += 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if s02[0] == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 - 4)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]  # print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Généralités repérées
    if s01[1] < int(s02[1] ** 1.6):
        v1 = y
        z1 = x
    else:
        v1 = s01[1] - int(s02[1] ** 1.6)
        z1 = s00[1] - int(s02[1] ** 1.6)
    if v1 % 6 != 1:
        if v1 % 6 == 0:
            v1 += 1
        else:
            v2 = v1 % 6 - 1
            v1 -= v2
    if z1 % 6 != 1:
        if z1 % 6 == 0:
            z1 += 1
        else:
            v2 = z1 % 6 - 1
            z1 -= v2
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
    # Fonction d'appel à condition NP
    itabtb = []
    itabmx = [0]
    itabqt = [0]
    itabqt[0] = 0
    itabgr = [0]
    itabgr[0] = 1
    def imemap(uz):
        """ Les nombres premiers NP
        Des préalables premiers :uz: déjà '1&5' """
        # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
        if not uno % uz and uz % 6 in (1, 3, 5) \
                and uz < 8:
            imem.append(uz)  # Tableau :imem[ip(NP)]:
        else:
            # :rim: Reconstruction à chaque tour
            rim = [mm for mm in imem if mm > 1]
            for rr in rim:
                if not uz % rr:
                    r0 = 1
                    break
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                ind0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                q = 0
                for iep in range(sq5, ind0, -1):
                    if not uz % iep \
                            and iep % 6 in (1, 5):
                        r0 = 1
                        if itabqt[0] == 1:
                            itabtb.append(iep)
                        else:
                            break
                    if not uz % (uz // iep) \
                            and (uz // iep) % 6 in (1, 5):
                        r0 = 1
                        if itabqt[0] == 1:
                            itabtb.append(uz // iep)
                        else:
                            break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                                and o % 6 in (1, 5):
                            r0 = 1
                            if itabqt[0] == 1:
                                itabtb.append(o)
                            else:
                                break
                        if not uz % (uz // o) \
                                and (uz // o) % 6 in (1, 5):
                            r0 = 1
                            if itabqt[0] == 1:
                                itabtb.append(uz // o)
                            else:
                                break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                                and p % 6 in (1, 5):
                            r0 = 1
                            if itabqt[0] == 1:
                                itabtb.append(p)
                            else:
                                break
                        if not uz % (uz // p) \
                                and (uz // p) % 6 in (1, 5):
                            r0 = 1
                            if itabqt[0] == 1:
                                itabtb.append(uz // p)
                            else:
                                break
                    q += 1
                else:
                    r0 = 0
 
            if r0 == 0:  # :for: Condition vide, donc.
                if itabqt[0] == 0:
                    imem.append(uz)
                    # Nombre premier NP
                else:
                    itabgr[0] = len(itabtb)
 
    if u1 == 0:  # Zéro issue
        # À la recherche des sous-multiples
        while itabgr[0]:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
                    and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y: :sq5|sut: Environnement
            if v > v1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Envoi :imemap: Sortant :v: NpP
                    if v == uo5:  # Carré rencontré Type 1
                        imemap(v)
                if not uno % v5 \
                        and v5 not in imem:
                    imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Carré rencontré Type 5
                        imemap(v5)
                if not uno % y \
                        and y not in imem:  # y = iut(+6)
                    imemap(y)
                if not uno % y5 \
                        and y5 not in imem:  # y5 = iut(+6)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
            # :w >= u: :s25|u: Environnement
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w and w not in imem:  # w = u25(-6)
                    imemap(w)
                if not uno % u and u not in imem \
                        and u % 6 in (1, 5) \
                        and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 and w5 > 1 \
                        and w5 not in imem:  # w5 = u25(-6)
                    imemap(w5)
            else:  # Si non: Indice terminal
                w_ = 1
            # :z >= x: :sut|s25: Environnement
            if z > z1 and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                        and z not in imem:  # z = iut(-6)
                    imemap(z)
                if not uno % x \
                        and x not in imem:  # x = u25(+6)
                    imemap(x)
                if not uno % z5 and z5 not in imem \
                        and z5 > 1:  # z5 = iut(-6)
                    imemap(z5)
                if not uno % x5 \
                        and x5 not in imem:  # x5 = u25(+6)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y * i
                    if i1 not in itab and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                itabmx[0] = uno // max(itab)
                if itabmx[0] // uno != 1:
                    it01 = len(itabtb)
                    if itabmx[0] > uo5 and itab is True:
                        itabqt[0] = 1
                        imemap(itabmx[0])
                    itabqt[0] = 0
                    for it in itabtb:
                        imemap(it)
                    it02 = len(itabtb)
                    if it01 == it02:
                        break
                else :
                    break
 
        print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
        uo6 = uno % 6
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_10a.py En {}'.format(time.time() - dod0))
onu = 98765432123456789
onuno(onu)