Discussion: classnph

  1. #41
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut print('nphysic_11a.py En {}'

    Quoi de plus subtil que d'entraver la multiplicité des lecteurs/cueilleurs de ce code, en cherchant parmi les communs rencontrés. Ainsi, on limite les itérations (+=6), en produisant les communs qui sont d'excellents producteurs de nombres préalables premiers. Et si ce cheminement se poursuit, ma foi on aura là une série non négligeable...

    Le code vous en dira bien plus que moi, et d'avantage si affinité

    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série communs. En Général Python
    import time
    import copy
    """MusicAToumic En"""
    # Programme      nphysic_11a : 27 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 = u2 = 0
        if uno == 0:  # :uno=0: Zéro issue
            uno = 1
            u1 = 1
        if uno == 1:  # :uno=1: Un issue
            u2 = 1
        uo5 = so5 = int(uno ** .5)
        uo6 = uno % 6
        u25 = s25 = int(uno ** .25)
        iut = sut = ((uo5 - u25) // 2)
        """
        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]
        # Blocages généraux
        if s00[1] > 4:
            if s01[1] < int(s02[1]):
                v1 = y
                z1 = x
            else:
                v1 = s01[1] - int((s02[1]))
                z1 = s00[1] - int((s02[1]))
            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
        else:
            """ Comme les issues(0&1)
            Lorsqu':uno: = Complexe racine² inférieure"""
            if uo5 % 6 == 1:
                v = uno
            else:
                v2 = uo5 % 6 - 1
                v = uo5 + v2
            v1 = 1
            z = 0
            z1 = 0
            w = 0
        # 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
        itabmx = [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 0 < uz < 8 and uz not in imem:
                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:
                        break
                else:
                    if uo5 > uz > 1:
                        imem.append(uz)
     
        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 w != 0:
                        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:
                        w_ = 1
                else:  # Si non: Indice terminal
                    w_ = 1
                # :z >= x: :sut|s25: Environnement
                if z > z1 and z_ == 0:  # Si oui: Faire z_
                    if z != 0:
                        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:
                        z_ = 1
                else:  # Si non: Indice terminal z_
                    z_ = 1
                # Ordonnées positives et négatives
                if v_ == 0:
                    if v1 == 1:
                        v -= 1
                    else:
                        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
        if u2 == 1:  # :uno=1: Un issue
            imem.append(1)
        # 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(imem)
                for i in imem:
                    for y in itab:
                        i1 = y * i
                        if i1 > uo5:
                            i1 = uno // i1
                            if i1 % 6 in (1, 5) and i1 not in itab \
                               and not uno % i1:
                                imemap(i1)
                        elif i1 not in itab and not uno % i1:
                            itab.append(i1)
                            # NC = Nombre Commun :itab[NC]: Résultat "ip"
                itab.sort()
                ion2 = len(imem)
                if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                    itabmx[0] = uno // max(itab)
                    if itabmx[0] // uno != 1:
                        imemap(itabmx[0])
                if len(imem) is not ion1:
                    pass
                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_11a.py En {}'.format(time.time() - dod0))
    onu = 9999876543210000123456789999
    onuno(onu)
    Pour vous rassurer, les prints

    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
     
    Nombres Premiers :ip: [1, 3, 11, 101]
    1 * 9999876543210000123456789999  typ 1*3
    3 * 3333292181070000041152263333  typ 3*3
    9 * 1111097393690000013717421111  typ 3*1
    11 * 909079685746363647586980909  typ 5*3
    33 * 303026561915454549195660303  typ 3*3
    99 * 101008853971818183065220101  typ 3*5
    101 * 99008678645643565578780099  typ 5*3
    303 * 33002892881881188526260033  typ 3*3
    909 * 11000964293960396175420011  typ 3*5
    1111 * 9000788967785778688980009  typ 1*3
    3333 * 3000262989261926229660003  typ 3*3
    9999 * 1000087663087308743220001  typ 3*1
    Cosmic 9999876543210000123456789999 typ 3 long 12
    nphysic_11a.py En 7.668458700180054
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  2. #42
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut nphermier_0a.py Simpliste

    Il y a des raisons de croire que le développement engendre la connaissance, en raison d'une conséquence liée au vecteur numéral. D'un côté, le nombre peut-être grand et donner lieu à une importante série de traitements gourmands en temps d'exécution. D'autre part, les qualités relatives à la multiplication des nombres entre eux et leurs effets visibles sur les produits. Alors on ne peut pas éviter de penser que les nombres sont finalement organisés, et que les relations peuvent être profondes. Il est important de savoir que la profondeur est distinguée, qu'elle est composée d'éléments distinctifs.

    Le programme précédent (nphysic_11a.py) a de nombreux traitements ne gênant pas le développement de l'idée originale, et grâce à sa logique heureusement simplifiable. Son enseignement donne l'occasion d'écrire un code plus simple, en ne gardant que la principale ligne de conduite de son algorithme. Résolu avec les nombres premiers aux production des communs, et de la science qui en découle. La relation avec les différents niveaux de profondeur estimée en grandeur numérale du nombre à traiter, pour que finalement on puisse interpréter le langage numéral après avoir compris sa systématique.

    Je voudrais remercier dans ce texte la communauté Pycharm de Jet Brain, qui fort compétant de disposer d'un éditeur de code agréable

    Code quantum d'un débutant non autonome et de ses deux amis Python et Pycharm
    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphermier_1 Le 9 septembre 2017
    import time
    import copy
    t = time.time()
    nombre = 9854632157861
    carre = carre1 = int(nombre ** .5)
    hautniveau = []
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    if carre % 6 == 1:
        carre1 = carre
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, carre, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse   
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                for i in hautniveau:
                    if not p1 % i:
                        break
                else:
                    hautniveau.append(p1)
            if not nombre % p5 and p5 not in hautniveau:
                for i in hautniveau:
                    if not p5 % i:
                        break
                else:
                    hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                for i in hautniveau:
                    if not carre1 % i:
                        break
                else:
                    hautniveau.append(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                for i in hautniveau:
                    if not carre5 % i:
                        break
                else:
                    hautniveau.append(carre5)
        carre1 -= 6
        carre5 -= 6
        # Contrôle jonction (+/-)
        if p1 >= carre1:
            break
    print('Hautniveau En:', time.time() - t)
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    for com1 in hautniveau:
        for com2 in communs:
            produit = com1 * com2
            # Condition de recherche
            if produit > carre:
                break
            elif produit not in communs and not nombre % produit:
                communs.append(produit)
                communs.sort()
                # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_0a.py En:', time.time() - t)
    print('', )
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  3. #43
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut

    Citation Envoyé par toumic Voir le message
    Il y a des raisons de croire que le développement engendre la connaissance,,,

    Je voudrais remercier dans ce texte la communauté Pycharm de Jet Brain, qui fort compétant de disposer d'un éditeur de code agréable

    Code quantum d'un débutant non autonome et de ses deux amis Python et Pycharm
    Pas facile de s'y retrouver parmi les communautés des multiples, car chaque nombre comporte une communauté différente. Et comme le code évolue en fonction des communs rencontrés, il est toujours probable qu'il ne soit pas totalement estimable comme son titre de réussite le demande

    L'algorithme relatif aux nombres a encore évolué, visiblement :
    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphermier_5a Le 17 septembre 2017
    import time
    import copy
    t = time.time()
    nombre = 7999178931971
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    palier = int(nombre ** .46)
    if typ6 in (1, 5):
        cartyp6 = int(nombre ** .473)
        borne = int(nombre ** .4)
    else:
        cartyp6 = int(nombre ** .437)
        borne = int(nombre ** .36)
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
     
    def compare(c):
        if not nombre % c and c <= carre:
            if c not in horscourse:
                horscourse.append(c)
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                if c <= carre and c not in hautniveau:
                    hautniveau.append(c)
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
        carre1 -= 6
        carre5 -= 6
        """Condition du palier:
            Nombres démunis en communs"""
        if p1 > palier and 2 > len(hautniveau):
            break
        """Condition de la borne:
        Nombres premiers complémentaires"""
        if p1 > borne and 1 < len(hautniveau):
            produit = 1
            hautniveau.sort()
            hautniveau.reverse()
            for unit in hautniveau:
                produit *= unit
                result = nombre // produit
                if result > 1 and not nombre % result:
                    if produit > carre and result not in horscourse:
                        compare(result)
                    elif nombre > produit < carre:
                        compare(produit)
            else:
                horscourse.sort()
                h = hh = 0
                while not hh:
                    h -= 1
                    fx_ip = nombre // horscourse[-1]
                    fx_mu = fx_ip * min(hautniveau)
                    if fx_mu < carre:
                        ho_dv = horscourse[h] // min(hautniveau)
                        if not nombre % ho_dv:
                            if ho_dv % 6 in (1, 5):
                                compare(ho_dv)
                        if not nombre % fx_mu:
                            if fx_mu > carre:
                                if (nombre // fx_mu) % 6 in (1, 5):
                                    compare(nombre // fx_mu)
                                    hh = 1
                            else:
                                if fx_mu % 6 in (1, 5):
                                    compare(fx_mu)
                    else:
                        hh = 1
                break
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    for com1 in hautniveau:
        for com2 in communs:
            produit = com1 * com2
            # Condition de recherche
            if produit > carre:
                break
            elif produit not in communs and not nombre % produit:
                communs.append(produit)
                communs.sort()
                # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_5a.py En:', time.time() - t)
    print('', )

    Pour cause cet exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Premiers [1, 758339]
    1 * 7999178931971 typ 1*5
    758339 * 10548289 typ 5*1
    nphermier_5a.py En: 0.2581496238708496
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  4. #44
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut L'Open Source Général Python

    J'avance dans mon programme, tout en perfectionnant la syntaxe logique du code. C'est agréable de se corriger, en aide aux idées fixées sur cette organisation. Elles répondent aux multiples demandes communes aux nombres, aussi il est naturel d'en faire profiter ceux qui aiment ce contexte. Car en classifiant ainsi les nombres on développe un avenir à ce "moteur", bien qu'au départ sa logique commune était liée aux nombres premiers, elle finira toujours par s'associer.
    Même si les grands nombres premiers ne sont pas atteints à cause d'une longue opération, pour ce jour. Après ce terme actuel, je suis content de publier

    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphermier_7a Le 1 octobre 2017
    import time
    import copy
    t = time.time()
    nombre = 965325462154786
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    """ Palier & Borne & cartyp6
    Palier : Limite en plein désert
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    palier = int(nombre ** .468)
    cartyp6 = int(nombre ** .36)
    borne = int(nombre ** .231)
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
     
    def compare(c):
        if c not in hautniveau:
            if c not in horscourse:
                horscourse.append(c)
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                if c <= carre:
                    hautniveau.append(c)
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
        carre1 -= 6
        carre5 -= 6
        """Condition du palier:
            Nombres démunis en communs"""
        if p1 > palier and 2 > len(hautniveau):
            break
        """Condition de la borne:
        Nombres premiers complémentaires"""
        if p1 > borne and 1 < len(hautniveau):
            produit = 1
            # Production des termes (1&5)
            # Résulte :result: de type (%6) variable
            for unit in hautniveau:
                produit *= unit
                result = nombre // produit
                if produit > carre:
                    compare(result)
                else:
                    compare(produit)
            else:
                """La production terminée
                Le hors course de son élément supérieur :max():
                Le haut niveau de son élément inférieur :min():
                """
                while 1:
                    fx_ip = nombre // max(horscourse)
                    fx_mu = fx_ip * min(hautniveau)
                    # Condition de la partie supérieure
                    if fx_mu > carre:
                        # Dépassement supérieur
                        while 1:
                            fx_in = nombre // fx_mu
                            if fx_in % 6 in (1, 5):
                                compare(fx_in)
                                break
                            else:
                                fx_mu = fx_mu * min(hautniveau)
                        break
                break
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    for com1 in hautniveau:
        for com2 in communs:
            produit = com1 * com2
            # Condition de recherche
            if produit > carre:
                break
            elif produit not in communs and not nombre % produit:
                communs.append(produit)
                communs.sort()
                # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_7a.py En:', time.time() - t)
    print('', )
    Encore une erreur qui s'est glissée, dans certains cas les nombres premiers affichent [1, 1,]. C'est assez important par rapport au temps d'exécution, puisque les nombres premiers se multiplient entre eux, et faire deux fois le tour avec ces deux fois (1) c'est limite rigolo
    Par chance je suis tombé dessus et corrigé illico, bien c'est vrai ça gagne en vitesse de production. La partie changée est la fonction "def compare", comme ce qui suit :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    def compare(c):
        if c not in hautniveau and c > 1:
    Cet exemple n'empêche pas l'envoi à la fonction de comparaison, un geste de transfert inutile et qui prend son temps. Puis en cherchant à savoir qui envoie ce (1) indésirable, on trouve cette émission dans la production des termes (1&5)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    # Production des termes (1&5)
            # Résulte :result: de type (%6) variable
            for unit in hautniveau:
                produit *= unit
                result = nombre // produit
                if produit > carre:
                    if result > 1:
                        compare(result)
                else:
                    compare(produit)
    Ainsi j'ai pu retirer un ordre de comparaison obsolète à la fonction compare
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    def compare(c):
        if c not in hautniveau:
    Un nombre est parvenu à me faire découvrir une faute d'appréciation = 9653254631547937. Il m'a fait comprendre que le champ des itérations n'était pas suffisant pour lui, il exige une première étape de modification au niveau...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    palier = int(nombre ** .468)
    cartyp6 = int(nombre ** .46)
    borne = int(nombre ** .368)
    Puis comme une boucle n'arrêtait pas de tourner, j'ai modifié une autre section...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    else:
                if produit == nombre:
                    break
                else:
                    """La production terminée
    Ce qui signifie que la composition des nombres premiers est complète. Eh hop
    Après une longue et mûre révision
    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 première. En Général Python
    # MusicAtoumic nphermier_8a Le 3 octobre 2017
    import time
    import copy
    t = time.time()
    nombre = 9653254631547937
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    nomproduit = 0
    """ Palier & Borne & cartyp6
    Palier : Limite en plein désert
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    palier = int(nombre ** .46)
    cartyp6 = int(nombre ** .36)
    borne = int(nombre ** .231)
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
     
    def compare(c):
        if c not in hautniveau:
            if c not in horscourse:
                horscourse.append(c)
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                if c <= carre:
                    hautniveau.append(c)
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
        carre1 -= 6
        carre5 -= 6
        """Condition du palier:
        Nombres démunis en communs"""
        if p1 > palier and 2 > len(hautniveau):
            break
        """Condition de la borne:
        Nombres premiers complémentaires"""
        if p1 > borne and 1 < len(hautniveau):
            produit = 1
            # Production des termes (1&5)
            # Résulte :result: de type (%6) variable
            for unit in hautniveau:
                produit *= unit
                result = nombre // produit
                if produit < nombre:
                    if produit > carre:
                        if result > 1:
                            compare(result)
                    else:
                        compare(produit)
                elif produit == nombre:
                    nomproduit = 1
            else:
                """La production terminée
                Le hors course de son élément supérieur :max():
                Le haut niveau de son élément inférieur :min():
                """
                while 1:
                    fx_ip = nombre // max(horscourse)
                    fx_mu = fx_ip * min(hautniveau)
                    if not nombre % fx_mu:
                        # Condition de la partie supérieure
                        if fx_mu > carre:
                            # Dépassement supérieur
                            while 1:
                                fx_in = nombre // fx_mu
                                if fx_in % 6 in (1, 5):
                                    compare(fx_in)
                                    break
                                else:
                                    fx_mu = fx_mu * min(hautniveau)
                            break
                    else:
                        break
                break
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    if nomproduit == 0:
        for com1 in hautniveau:
            for com2 in communs:
                produit = com1 * com2
                # Condition de recherche
                if produit > carre:
                    break
                elif produit not in communs and not nombre % produit:
                    communs.append(produit)
                    communs.sort()
                    # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_8a.py En:', time.time() - t)
    print('', )
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  5. #45
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Le Premier Pas

    C'est parce que je travaille sur cette série des communs, que je rencontre des séries qui ne sont pas communes. Les nombres premiers sont les tempéraments utilisés à des fins itératives, et comme je le disais :
    Le poids du nombre premier multiple, donne la cadence relative au contexte en cours. Pour le démontrer prenons par exemple la suite des nombres premiers, étant les premiers multiples liés à "9653254631547937" : Premiers [1, 38861, 379417, 654701].
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    Premiers [1, 38861, 379417, 654701]
    1 * 9653254631547937 typ 1*1
    38861 * 248404689317 typ 5*5
    379417 * 25442335561 typ 1*1
    654701 * 14744524037 typ 5*5
    . L'ensemble inférieur des couplages est composé de nombres premiers uniquement. Où l'intervalle est démuni de commun, en dimensionnant les nombres premiers relatifs. Ce qui devient particulier lorsqu'on regarde du côté de l'association listée.

    • Nombre = 9653254631547937
    • Associée = 1*38861*379417*654701 = 9653254631547937
    • Nombre = Associée

    Cette situation a méritée une révision au niveau de la multiplication à charge de produire les communs, car aucun besoin de produire si c'est pour obtenir le même.
    Un autre exemple "125492310210123181", suite au précédent. Dans l'idée de multiplier les nombres premiers entre eux, de produire le nombre avec lequel on a à charge de calculer les communs, comme çà en ajoutant 13 en tant que multiplicateur.

    • Associée = 1*38861*379417*654701*13 = 125492310210123181
    • Nombre = 125492310210123181
    • Nombre = Associée

    En faisant cela, on ajuste le conditionnement qui au départ est "Nombre = Associée". Alors, ce n'est pas nécessaire de produire. Qui à l'arrivée est faux tant qu'on ne modifie pas la condition :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    elif produit == nombre:
                    for h in horscourse:
                        if h not in hautniveau:
                            nomproduit = 0
                            break
    Ceci indique, qu'une unité hors course ne figure pas au haut niveau. Et, il est important de produire des communs...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    Premiers [1, 13, 38861, 379417, 654701]
    1 * 125492310210123181 typ 1*1
    13 * 9653254631547937 typ 1*1
    38861 * 3229260961121 typ 5*5
    379417 * 330750362293 typ 1*1
    505193 * 248404689317 typ 5*5
    654701 * 191678812481 typ 5*5
    4932421 * 25442335561 typ 1*1
    8511113 * 14744524037 typ 5*5

    Programme Principal
    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 première. En Général Python
    # MusicAtoumic nphermier_8a Le 7 octobre 2017
    import time
    import copy
    t = time.time()
    nombre = 6532987825369
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    """ Palier & Borne & cartyp6
    Palier : Limite en plein désert
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    palier = int(nombre ** .39)
    cartyp6 = int(nombre ** .36)
    borne = int(nombre ** .33)
    nomproduit = 0
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
     
    def compare(c):
        if c not in hautniveau:
            if c not in horscourse:
                horscourse.append(c)
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                if c <= carre:
                    hautniveau.append(c)
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
        carre1 -= 6
        carre5 -= 6
        """Condition du palier:
        Nombres démunis en communs"""
        if p1 > palier and 2 > len(hautniveau):
            break
        """Condition de la borne:
        Nombres premiers complémentaires"""
        if p1 > borne and 1 < len(hautniveau):
            produit = 1
            # Production des termes (1&5)
            # Résulte :result: de type (%6) variable
            for unit in hautniveau:
                produit *= unit
                result = nombre // produit
                if produit < nombre:
                    if produit > carre:
                        compare(result)
                    else:
                        compare(produit)
                elif produit == nombre:
                    for h in horscourse:
                        if h not in hautniveau:
                            nomproduit = 0
                            break
                    else:
                        nomproduit = 1
            else:
                """La production terminée
                Le hors course de son élément supérieur :max():
                Le haut niveau de son élément inférieur :min():
                """
                while 1:
                    fx_ip = nombre // max(horscourse)
                    fx_mu = fx_ip * min(hautniveau)
                    if fx_ip > carre:
                        fx_mu = fx_ip
                    if not nombre % fx_mu:
                        # Condition de la partie supérieure
                        if fx_mu > carre:
                            # Dépassement supérieur
                            while 1:
                                fx_in = nombre // fx_mu
                                if fx_in % 6 in (1, 5) and not nombre % fx_in:
                                    compare(fx_in)
                                    break
                                elif not nombre % fx_in:
                                    fx_mu = fx_mu * min(hautniveau)
                                else:
                                    break
                            break
                    else:
                        break
                break
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    if nomproduit == 0:
        for com1 in hautniveau:
            for com2 in communs:
                produit = com1 * com2
                # Condition de recherche
                if produit > carre:
                    break
                elif produit not in communs and not nombre % produit:
                    communs.append(produit)
                    communs.sort()
                    # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_8a.py En:', time.time() - t)
    print('', )
    Pourquoi retirer le niveau palier suivant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
        """Condition du palier:
            Nombres démunis en communs"""
        if p1 > palier and 2 > len(hautniveau):
            break
    Condition inutilisée car le comptage effectué par la boucle "for" qui suit
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
    Fait que le lecteur P1 s'arrête à
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    cartyp6 = int(nombre ** .36)
    Erreur élémentaire
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  6. #46
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Harmonie des nombres

    Citation Envoyé par toumic Voir le message
    C'est parce que je travaille sur cette série des communs
    Erreur élémentaire
    D'erreur en erreur, de l'attention portée à la nouvelle condition, et enfin au cas par cas des corrections. La recherche originale consiste à comparer les sous-multiples, une manière plus rapide que l'itération qui apporte son lot de données. Bien que les nombres entiers originaux soient confondus par l'une des conditions dans sa production des communs, et pas par l'autre. Sans aller à une condition par nombre, mais en réunissant les éléments révélateurs du développement. Y parvenir du premier coup est balaise, sauf qu'il m'a fallut plus de temps pour une unième réponse au sujet de l'harmonie des nombres.
    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
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Origine : nphermier_9a Du 8 octobre 2017
    # MusicAtoumic nphullmen_0a Le 20 octobre 2017
    import time
    import copy
    t = time.time()
    nombre = 125492310210123181
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    hautmulti_ = [0]
    hautmulti_[0] = 1
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = int(nombre ** .5)
    borne = int(nombre ** .46)
    # print('c6 %s bn %s' % (cartyp6, borne))
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
            horscourse.append(i)
     
    def compare(c):
        """Recherches thématiques"""
        if c not in horscourse:
            horscourse.append(c)
        if c not in hautniveau:
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                hautmulti_[0] = 1
                if c <= carre:
                    hautniveau.append(c)
                    for h in hautniveau:
                        hautmulti_[0] *= h
                    if len(hautniveau) > 1:
                        for c1 in sorted(hautniveau):
                            for c2 in horscourse:
                                c12 = c1 * c2
                                if not nombre % c12:
                                    if c12 > nombre:
                                        break
                                    elif c12 <= carre:
                                        if c12 not in horscourse:
                                            horscourse.append(c12)
                                            horscourse.sort()
                if hautmulti_[0] == nombre:
                    hautmulti_[0] = 0
                if hautmulti_[0] * min(hautniveau) >= nombre:
                    hautmulti_[0] = 0
                if hautmulti_[0] > (nombre // hautniveau[1]):
                    hautmulti_[0] = 0          
                if hautmulti_[0] <= carre:
                    if hautmulti_[0] * min(hautniveau) >= carre:
                        ip = nombre // hautmulti_[0]
                        if not nombre % ip and ip % 6 in (1, 5):
                            if ip <= carre:
                                compare(ip)
                            """else:
                                hautmulti_[0] = 1
                                print('else')"""
                        elif max(horscourse) >= carre:
                            hautmulti_[0] = 0
                else:
                    pas = []
                    ip = nombre // hautmulti_[0]
                    if ip not in horscourse:
                        compare(ip)
                        while not nombre % ip:
                            ip //= min(hautniveau)
                            pas.append(ip)
                        if len(pas) > 1:
                            compare(pas[-2])
                        elif not nombre % pas[0]:
                            compare(pas[0])
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
     
        if hautmulti_[0] == 0:
                break
        elif p1 > borne and len(hautniveau) < 2:
            break
     
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
                horscourse.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
                horscourse.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
                horscourse.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
                horscourse.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
        carre1 -= 6
        carre5 -= 6
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    horscourse.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(horscourse)
    for i in sorted(communs):
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphullmen_0a.py En:', time.time() - t)
    print('', )
    Et sa version étudiant avec les prints qui aident à appréhender les processus liés aux recherches multiplicatives des sous-multiples actifs
    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
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Origine : nphermier_9a Du 8 octobre 2017
    # MusicAtoumic nphullmen_0 Le 17 octobre 2017
    """Version étudiant"""
    import time
    import copy
    t = time.time()
    # Nombres extraordinnaires
    # 6546278953879
    # 123456789123456789
    # 125492310210123181
    nombre = 6546278953879
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    hautmulti_ = [0]
    hautmulti_[0] = 1
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = int(nombre ** .5)
    borne = int(nombre ** .46)
    print('c6 %s bn %s' % (cartyp6, borne))
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
            horscourse.append(i)
     
    def compare(c):
        #print(p1, 'compare c', c)
        if c not in horscourse:
            horscourse.append(c)
        if c not in hautniveau:
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                hautmulti_[0] = 1
                if c <= carre:
                    hautniveau.append(c)
                    for h in hautniveau:
                        hautmulti_[0] *= h
                    #print(p1, 'compare else hors', max(horscourse))
                    print(p1, 'compare hautniveau', hautniveau)
                    print(p1, 'compare hautmulti_', hautmulti_[0])
                    print('')
                    #hautniveau.sort()
                    #print('compare horscourse', horscourse)
                    #print('compare hautniveau', hautniveau)
                    if len(hautniveau) > 1:
                        for c1 in sorted(hautniveau):
                            for c2 in horscourse:
                                c12 = c1 * c2
                                #print('compare c12 =', c12)
                                if not nombre % c12:
                                    if c12 > nombre:
                                        #print('compare c12 > carre', c12)
                                        break
                                    elif c12 <= carre:
                                        if c12 not in horscourse:
                                            horscourse.append(c12)
                                            horscourse.sort()
                                            #print('compare elif hors', c12)
                        print(p1, 'compare len max(hors)', max(horscourse))
                if hautmulti_[0] == nombre:
                    print(c, 'comp break nombre=multi_', hautmulti_)
                    hautmulti_[0] = 0
                if hautmulti_[0] * min(hautniveau) >= nombre:
                    hautmulti_[0] = 0
                    print(c, 'comp break nombre*min multi_', hautmulti_)
                if hautmulti_[0] > (nombre // hautniveau[1]):
                    hautmulti_[0] = 0
                    print(c, 'comp break multi_ n/haut', hautmulti_)          
                if hautmulti_[0] <= carre:
                    print('hautmulti_[0] <= carre', hautmulti_)
                    if hautmulti_[0] * min(hautniveau) >= carre:
                        ip = nombre // hautmulti_[0]
                        print(c, 'comp ip = n/multi_', ip)
                        if not nombre % ip and ip % 6 in (1, 5):
                            if ip <= carre:
                                compare(ip)
                                print(c, 'comp ip < car', ip)
                            """else:
                                hautmulti_[0] = 1
                                print(c, 'comp break nombre%ip else', ip)"""
                        elif max(horscourse) >= carre:
                            print(c, 'comp break carre multi_', hautmulti_[0],
                                  'ip', ip)
                            hautmulti_[0] = 0
                else:
                    pas = []
                    ip = nombre // hautmulti_[0]
                    print(c, 'else nombre%ip', ip)
                    if ip not in horscourse:
                        compare(ip)
                        print('ip not', ip, min(hautniveau))
                        while not nombre % ip:
                            ip //= min(hautniveau)
                            pas.append(ip)
                            #print(c, 'while pas ', pas, 'len(pas)', len(pas))
                        if len(pas) > 1:
                            compare(pas[-2])
                            #print(c, 'len(pas)>1', pas)
                        elif not nombre % pas[0]:
                            compare(pas[0])
                            #print(c, 'len(pas)<1', pas)
     
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
     
        if p1 > cartyp6 - 12:
            print('point p1 car', p1)
        if hautmulti_[0] == 0:
                print('break p1 multi_', p1, hautmulti_)
                break
        elif p1 > borne and len(hautniveau) < 2:
            print('break p1 borne', p1, borne)
            break
     
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
                horscourse.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
                horscourse.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
                horscourse.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
                horscourse.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
                print('   p1', p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
                print('   p5', p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
                print('   carre1', carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
                print('   carre5', carre5)
        carre1 -= 6
        carre5 -= 6
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    horscourse.append(1)
    hautniveau.sort()
    #horscourse.sort()
    #print('Horscourse', horscourse)
    print('Premiers', hautniveau)
    communs = copy.copy(horscourse)
    for i in sorted(communs):
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphullmen_0.py En:', time.time() - t)
    print('', )
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  7. #47
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut nphullmen_3 (étudiant)

    Le dernier problème = Nombre de type 1 ayant 2 nombres premiers inférieurs comme diviseurs.
    En effet de multiplier les nombres premiers (haut multi), avec le nombre premier minimum (min(hautniveau)). Nous indique que le maximum du haut niveau est atteint, selon cette condition (L74):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if hautmulti_[0]*min(hautniveau) >= carre:
    La production "haut multi", résulte de la multiplication de tous les nombres premiers contenus dans la table du haut niveau. Sous cette condition nous obtenons le nombre DV ainsi : Le haut niveau multiplié par son minimum, produit un commun supérieur à la racine carrée (espace de recherche).
    Je rappelle que les communs inférieurs à la racine carrée sont des nombres IP (pour le cas), et ceux qui lui sont supérieurs sont des nombres DV (idem)
    . Le DV représente le lien entre les multiples liés à un nombre premier, et en faisant une simple division on a le IP d'un autre tempérament commun. Le code nous explique tout ceci et bien plus
    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Origine : nphermier_9a Du 8 octobre 2017
    # MusicAtoumic nphullmen_3 Le 29 octobre 2017
    """Version étudiant"""
    import time
    t = time.time()
    # Nombres extraordinnaires
    # 6546278953879
    # 9876543210123456789
    # 123456789123456789
    # 125492310210123181
    # 9999876543210000123456789999
    nombre = 123456789123456789
    print('Cosmic =', nombre)
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    hautcommun = []
    hautmulti_ = [0]
    hautmulti_[0] = 1
    p1 = 7
    p5 = 11
    pont0 = [0]
    pont0[0] = 0
    pont1 = [0]
    pont1[0] = 0
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = int(nombre ** .5)
    borne = int(nombre ** .46)
    print('cartyp6 %s borne %s' % (cartyp6, borne))
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
            horscourse.append(i)
     
    def compare(c):
        hautmulti_[0] = 1
        if c not in horscourse:
            horscourse.append(c)
            print('C horscourse', c)
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                #print('C multi_', hautmulti_)
                if c <= carre:
                    hautniveau.append(c)
                    for h in hautniveau:
                        hautmulti_[0] *= h
                    if len(hautniveau):
                        for c1 in sorted(hautniveau):
                            for c2 in horscourse:
                                c12 = c1 * c2
                                if not nombre % c12 \
                                   and c12 not in horscourse \
                                   and c12 <= carre:
                                    horscourse.append(c12)
                                    horscourse.sort()
                                    #print('c12 elif hors', c12)
                # Terme racine        
                if hautmulti_[0] == nombre:
                    print(c, 'BREAK nombre=multi_', hautmulti_)
                    hautmulti_[0] = 0
                if hautmulti_[0] * min(hautniveau) >= nombre:
                    print(c, 'BREAK multi_*min>=n ', hautmulti_)
                    hautmulti_[0] = 0
                if hautmulti_[0] > (nombre // hautniveau[1]):
                    print(c, 'BREAK multi_>n/haut', hautmulti_)
                    hautmulti_[0] = 0
                # Terme commun     
                if hautmulti_[0] <= carre:
                    if hautmulti_[0]:
                        print(p1, 'HAUTmulti_[0]', hautmulti_[0])
                        print('MAX(hautniveau)', max(hautniveau))
                        print('MAX(horscourse)', max(horscourse))
                        if hautmulti_[0]*min(hautniveau) >= carre:
                            hdv = hautmulti_[0]*min(hautniveau)
                            hip = nombre // hdv
                            print('HDV', hdv,hdv%6, 'HIP', hip,hip%6)
                            if not nombre % hip \
                               and hip not in hautniveau:
                                pont1[0] = int(hip**.5)
                                pont0[0] = hip
                                print(p1, 'p1>PONT', pont0[0])
                else:
                    if pont0[0]:
                        hop = pont0[0] // max(hautniveau)
                        compare(hop)
     
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    while p1 <= cartyp6:
     
        if p1 > cartyp6 - 12:
            print('point p1&5 car', p1)
            break
        if hautmulti_[0] == 0:
            print('break p1 multi_', p1, hautmulti_)
            break
        elif p1 > borne:
            print('break p1 borne', p1, borne, hautniveau)
            break
        elif pont0[0]:
            if p1 > pont1[0]:
                compare(pont0[0])
                print('break pont1[0]', pont1[0])
                break
     
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
                horscourse.append(p1)
                #print('  not p1', p1)
            if not nombre % p5:
                hautniveau.append(p5)
                horscourse.append(p5)
                #print('  not p5', p5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                #print('   p1', p1, p1%6)
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                #print('   p5', p5, p5%6)
                compare(p5)        
        p1 += 6
        p5 += 6
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    horscourse.append(1)
    hautniveau.sort()
    #print('Horscourse', horscourse)
    print('Premiers', hautniveau)
    for i in sorted(horscourse):
        print('{} * {} typ {}*{}'
              .format(i, nombre // i, i % 6, (nombre // i) % 6))
        break
    print('max(hors)', max(horscourse), 'dv', nombre//max(horscourse))
    print('nphullmen_3.py En:', time.time() - t)
    print('', )
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  8. #48
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Cosmic 9998765432100012345678999

    Citation Envoyé par toumic Voir le message
    Le dernier problème = Nombre de type 1 ayant 2 nombres premiers inférieurs comme diviseurs.
    En effet de multiplier les nombres premiers (haut multi), avec le nombre premier minimum (min(hautniveau)). Nous indique que le maximum du haut niveau est atteint, selon cette condition (L74):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if hautmulti_[0]*min(hautniveau) >= carre:
    . Le DV représente le lien entre les multiples liés à un nombre premier, et en faisant une simple division on a le IP d'un autre tempérament commun. Le code nous explique tout ceci et bien plus
    Selon que l'on crée une condition de recherche non itérative mais calculée à l'aide des communs en cours, ainsi que de l'endroit où se situe cette condition (soit la fonction des lecteurs :CoComm():, soit dans celle-ci :Racine. Je ne vais pas m'étendre là-dessus, puisque la solution avance bien jusqu'à ce que l'intervalle séparant deux nombres premiers de grande envergure. Obtenir la position des Lecteurs-Type (1&5), afin de recommencer les itérations à un autre niveau des préalables communs en milieu de la racine carrée. C'est en créant la liste des communs (premiers/non premiers) que s'est imposée la sortie de ces éléments, en effet à chaque sortie correspond une limite commune aux multiples déterminant aussi un échelonnage intégré (non commun).

    Actuellement, bien avancé avec ces "trous noirs" qui commencent à partir des limites non communes, et qui font partie entière de l'espace "cosmique" réservé aux nombres. Je vous propose le code version originale et sa fenêtre d'édition en copie.

    Code PyCosmic.py

    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
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Origine : Cosmic 9876543210123456789
    # MusicAtoumic PyCosmic_2 Ce 5 novembre 2017
    # Collection Python Compulse
    """ Version originale"""
    import time
    t = time.time()
    Premiers = [1]
    Presigne = [0]
    Presigne[0] = 1
    Fermiers = [1]
    Ramieres = [1]
    maxFerme = [0]
    maxFerme[0] = 1
    COMPTEUR = 1
    # En cours: 9987654321001234567899
    # Origine Cosmic
    Cosmic = 9998765432100012345678999
    snScript = 0  # := 1: Affiche les communs
    sQuare = int(Cosmic ** .5)
    print('Cosmic', Cosmic)
    print('square', sQuare)
    # Zéro issue
    limit = 0
    if Cosmic not in (0, 1, 2, 3, 5):
        # Lecteurs limite
        limit = 1
        # Coaxe de base
        Coaxes = [2, 3, 5]
        for i in range(7):
            if i in Coaxes and not Cosmic % i:
                Premiers.append(i)
                Fermiers.append(i)
                Presigne[0] = i  # Première signature
                print('Coaxes Presigne', Presigne)
     
        def Racine(cine):
            """Espace RacPrime(cine):
            Comparaison avec la racine première commune
            Composition des préalables nombres premiers"""
            print('Espace RacPrime(cine)', cine, Premiers)
     
            RacPre = []  # maxFerme[0] = max(Fermiers)
            for pre in Premiers:
                sec = cine // pre
                if not cine % sec and sec not in Premiers:
                    # Cas: Premier * Premier = Cosmic
                    cine = sec
                    print(' R Racine(sec)', sec)
            # maxFerme[0] = max(Fermiers)
            if Premiers:
                dvMaxfer = Cosmic // maxFerme[0]
                ipMaster = dvMaxfer // cine
                if ipMaster not in Fermiers:
                    if ipMaster >= sQuare and max(Premiers) > 1:
                        ipMaster = ipMaster // Premiers[1]
                    RacPre.append(cine)
                    RacPre.append(ipMaster)
                    print(' R RacPre', RacPre)
     
            for Rac in RacPre:
                cine = Rac
                for pre in Premiers:
                    if not cine % pre and pre > 1:
                        break
                else:
                    if cine <= sQuare:
                        Premiers.append(cine)
                        Premiers.sort()
                        Fermiers.append(cine)
                        Presigne[0] = cine  # Première signature
                        print(' R cine', cine)
     
        def CoComm(coco):
            """Espace CoComm(coco):
            Lecteurs à intervalles donnés
            Cueilleurs aux moments donnés"""
            print('Espace CoComm(coco)', coco)
     
            if len(Premiers) > 1 and coco == 1:
                coco = max(Premiers)
                co6 = coco % 6
                if co6 == 5:
                    coco -= 4
     
            # Réglages (1&5)
            if coco < 7:
                car1 = 7
                car5 = 11
            else:
                car1 = coco
                if car1 % 6 == 1:
                    car5 = car1 - 2
                else:
                    differe = (car1 % 6) - 1
                    car1 -= differe
                    car5 = car1 - 2
            Lectyp1 = car1
            Lectyp5 = car5
            # Intervalle :CaxeP: maxPremiers(sup(square))
            if len(Premiers) > 1 and max(Premiers) != max(Fermiers):
                CipdP = max(Premiers)
                CpdvP = Cosmic // CipdP
                CaxeP = int(CpdvP ** .5)
                CmaxP = max(Premiers) * Fermiers[-2]
                print(' C CaxeP CmaxP', CaxeP, CmaxP)
            else:
                CaxeP = sQuare
            Presigne[0] = 0
            w = 0
            # Lecture Temps six
            while not Presigne[0]:
                if w < 2:
                    w += 1
                    # print(' C Lctp15', Lectyp1, Lectyp5)
                if not Cosmic % Lectyp1 and Lectyp1 not in Premiers:
                    if Lectyp1 not in Fermiers:
                        print(' C Lectyp1', Lectyp1)
                        Racine(Lectyp1)
                        break
                elif not Cosmic % Lectyp5 and Lectyp5 not in Premiers:
                    if Lectyp5 not in Fermiers:
                        print(' C Lectyp5', Lectyp5)
                        Racine(Lectyp5)
                        break
                Lectyp1 += 6
                Lectyp5 += 6
                if Lectyp1 > CaxeP:
                    print(' C break CaxeP', CaxeP)
                    break
     
        def CoMulti():
            """Espace CoMulti():
            Accumulation des nouveaux communs
            Formation des nouvelles données"""
            print('Espace CoMulti()')
     
            for p1 in Premiers:
                for f1 in Fermiers:
                    produit = p1 * f1
                    # Condition commune
                    while not Cosmic % produit:
                        if produit not in Fermiers:
                            Fermiers.append(produit)
                            Fermiers.sort()
                        break
                    else:
                        if produit not in Ramieres:
                            RamPro = p1, produit
                            Ramieres.append(RamPro)
            #Ramieres.sort(Ramieres[0])
            maxFerme[0] = max(Fermiers)
            print('  CoMulti maxFerme =', maxFerme)
            print('  CoMulti Premiers =', Premiers)
            print('  CoMulti maxFermiers =', Fermiers)
            print('  CoMulti maxRamieres =', Ramieres)
     
        # Espace appelant
        while Presigne[0]:
            print('#  W LIMIT + COMPTEUR ____________:', limit, COMPTEUR)
            print('')
     
            if max(Fermiers) <= Cosmic:
                CoMulti()
            # Fermiers(ipMax) ______________
            # print('#  F Fermiers:', Fermiers)
            if max(Fermiers) >= sQuare:
                # (':Fermiers=Cosmic: Communs Complets')
                if max(Fermiers) == Cosmic:
                    print('#  F break maxFermiers(Cosmic):', Cosmic)
                    break
            elif len(Fermiers) > 1:
                dvFer = max(Fermiers) * Premiers[1]
                if dvFer >= sQuare:
                    ipFer = Cosmic // dvFer
                    if ipFer in Premiers:
                        print('#  F break maxFermiers(ipFer):', ipFer)
                        break
            # Limites ___________________
            # print('#  L Premiers:', limit)
            if 1 < len(Premiers) < 2:
                Lpr = Premiers[1]
            else:
                Lpr = limit
            print('#  L Limite Lpr', Lpr)
            print('#  L Lpr Presigne', Lpr, Presigne[0])
            if limit != 0:
                CoComm(Lpr)
            COMPTEUR += 1
    # ########## #   ZERO   ISSUE   # ########################### #
    else:  # Zéro issue
        Fermiers = []
        Premiers = [0]
        Premiers[0] = 0
        if not Cosmic:
            Fermiers.append(Cosmic)
            Fermiers.append(Cosmic)
        else:
            Fermiers.append(Cosmic)
        print('Z  Zéro issue:', limit)
    # ########################################################### #
    fer = len(Fermiers)
    print('\n Premiers Libres Communs(', fer, ')ex \n', 'PL', Premiers)
    if snScript:
        Libre = {}
        if not Cosmic:  # Zéro issue
            Libre[Cosmic] = Fermiers[1]
        else:
            for ff in Fermiers:
                if ff <= sQuare:
                    f = ff
                    Libre[f] = Cosmic // ff
                else:
                    f = Cosmic // ff
                    Libre[f] = ff
        for ip, dv in sorted(Libre.items()):
            print('{} * {} typ {}*{}'
                  .format(ip, dv, ip % 6, dv % 6))
    print('\n PyCosmic_2.py En: \n', time.time() - t)
    Code résultat

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    >>> 
     RESTART: C:\Users\Vincent\Documents\developpez\labowa\laboNPH\nphysic\nphermier\nphumier\PythonCosmic\PyCosmic_2.py 
    Cosmic 9998765432100012345678999
    square 3162082451818
    Coaxes Presigne [3]
    #  W LIMIT + COMPTEUR ____________: 1 1
    Espace CoMulti()
      CoMulti maxFerme = [9]
      CoMulti Premiers = [1, 3]
      CoMulti maxFermiers = [1, 3, 9]
      CoMulti maxRamieres = [1, (3, 27)]
    #  L Limite Lpr 1
    #  L Lpr Presigne 1 3
    Espace CoComm(coco) 1
     C CaxeP CmaxP 1825629154757 9
     C Lectyp1 7
    Espace RacPrime(cine) 7 [1, 3]
     R Racine(sec) 7
     R RacPre [7, 52903520804761970082957]
     R cine 7
    #  W LIMIT + COMPTEUR ____________: 1 2
    Espace CoMulti()
      CoMulti maxFerme = [63]
      CoMulti Premiers = [1, 3, 7]
      CoMulti maxFermiers = [1, 3, 7, 9, 21, 63]
      CoMulti maxRamieres = [1, (3, 27), (3, 27), (3, 189), (7, 49), (7, 147), (7, 441)]
    #  L Limite Lpr 1
    #  L Lpr Presigne 1 7
    Espace CoComm(coco) 1
     C CaxeP CmaxP 1195154827513 147
     C Lectyp5 11987
    Espace RacPrime(cine) 11987 [1, 3, 7]
     R Racine(sec) 11987
     R RacPre [11987, 4413407925649617926]
     R cine 11987
    #  W LIMIT + COMPTEUR ____________: 1 3
    Espace CoMulti()
      CoMulti maxFerme = [755181]
      CoMulti Premiers = [1, 3, 7, 11987]
      CoMulti maxFermiers = [1, 3, 7, 9, 21, 63, 11987, 35961, 83909, 107883, 251727, 755181]
      CoMulti maxRamieres = [1, (3, 27), (3, 27), (3, 189), (7, 49), (7, 147), (7, 441), (3, 27), (3, 189), (3, 323649), (7, 49), (7, 147), (7, 441), (7, 587363), (7, 1762089), (7, 5286267), (11987, 143688169), (11987, 431064507), (11987, 1005817183), (11987, 1293193521), (11987, 3017451549), (11987, 9052354647)]
    #  L Limite Lpr 1
    #  L Lpr Presigne 1 11987
    Espace CoComm(coco) 1
     C CaxeP CmaxP 28881379779 3017451549
    ========================== RESTART: Shell ==========================
    >>>
    Pour ce qui est espéré

    # PC 9co.py
    """
    Cosmic 9998765432100012345678999 typ 3
    cartyp6 3162082451818 borne 316209806804
    Premiers [1, 3, 7, 11987, 3048439991, 4343278469]
    1 * 9998765432100012345678999 typ 1*3|
    3 * 3332921810700004115226333 typ 3*3|[1, 3, 7]
    7 * 1428395061728573192239857 typ 1*3|[1, 3, 7]
    9 * 1110973936900001371742111 typ 3*5|3 * 3 produit = 9
    21 * 476131687242857730746619 typ 3*3|3 * 7 produit = 21
    63 * 158710562414285910248873 typ 3*5|3 * 21 produit = 63
    11987 * 834134097947777788077 typ 5*3
    35961 * 278044699315925929359 typ 3*3
    83909 * 119162013992539684011 typ 5*3
    107883 * 92681566438641976453 typ 3*1
    251727 * 39720671330846561337 typ 3*3
    755181 * 13240223776948853779 typ 3*1
    3048439991 * 3279961377497889 typ 5*3
    4343278469 * 2302123960843371 typ 5*3
    9145319973 * 1093320459165963 typ 3*3
    13029835407 * 767374653614457 typ 3*3
    21339079937 * 468565911071127 typ 5*3
    27435959919 * 364440153055321 typ 3*1
    30402949283 * 328874851549053 typ 5*3
    39089506221 * 255791551204819 typ 3*1
    64017239811 * 156188637023709 typ 3*3
    91208847849 * 109624950516351 typ 3*3
    192051719433 * 52062879007903 typ 3*1
    273626543547 * 36541650172117 typ 3*1
    # nphullmen_3a.py En: 1021.7947270870209
    """
    Cosmic = 9998765432100012345678999
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  9. #49
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Unième mofification de nphullmen_3a.py

    Ainsi:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
            horscourse.append(i)
    Dans le report bas niveau ne sont pas traités (4, 6)
    Noter qu'ensuite, les points (p1&p5) sont à (7, 11)
    Si quatre est un sous-multiple, ici il est absent


    Pour y remédier, une simple mofification suffit:
    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
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(2, 7):
        if not nombre % i:
            def rang(ti, i_):
                if ti == 1:
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:
                    horscourse.append(i_)
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  10. #50
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Tapis magique

    J'avoue, je fais des erreurs, ce n'est pas encore ça. Mais le sujet est compliqué, je débute en ayant vu des choses, et en oubliant de les appliquer. C'est alors, qu'il faut poser un topique. Tout en ayant pas peur de tout devoir reprendre, sauf qu'en cours de route on code tout ce qu'il faut pour interpréter la vaste communauté des nombres. Tout en notant quelques notions basiques et répétitives ou communes à certains nombres. Je vous propose un outillage intellectuel basé sur des incantations de l'homme qui a vu...

    # PyCosmic 4: Dossier typic
    """
    typ 0_________________________________________________
    Cosmic = 357951258456 typ 0
    square = 598290
    PL [1, 2, 3, 11, 11587, 117017](*) = 89487814614
    (ip*dv(axe)) = 4 * 89487814614 typ 4*0
    (ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0
    # F break maxFermiers(Cosmic): 357951258456

    Cosmic = 765432198765432 typ 0
    square = 27666445
    PL [1, 2, 3, 11](*) = 66
    (ip(axe)*dv) = 66 * 11597457557052 typ 0*0
    (ip(sup)*dv(inf)) = 7128 * 107383866269 typ 0*5
    CoMulti maxFermiers = 7128
    C break CaxeP 8341747
    typ 1_________________________________________________
    Cosmic = 428622468822709 typ 1
    square = 20703199
    PL [1, 7, 953](*) = 6671
    (ip(sup)*dv(inf)) = 6671 * 64251606779 typ 5*5
    CoMulti maxFermiers = 6671
    C break CaxeP 670642

    Cosmic = 84269713568423971 typ 1
    square = 290292462
    PL [1, 7, 23, 151](*) = 24311
    (ip(axe)*dv) = 24311 * 3466320331061 typ 5*5
    (ip(sup)*dv(inf)) = 170177 * 495188618723° typ 5*5
    CoMulti maxFermiers = 170177
    C break CaxeP 23623665
    typ 2_________________________________________________
    Cosmic = 23521654248938 typ 2
    square = 4849912
    PL [1, 2, 83, 9949](*) = 1651534
    (ip(sup)*dv(inf)) = 1651534 * 14242307 typ 4*5
    CoMulti maxFermiers = 1651534
    C break CaxeP 48623

    Cosmic 26846125345688 typ 2
    cartyp6 5181324
    PL [1, 2, 11, 17](*) = 374
    (ip(axe)*dv) = 374 * 71781083812 typ 2*4
    (ip(sup)*dv(inf)) = 1496 * 17945270953 typ 2*1
    C len(haut) horscourse 1496
    W break cartyp6 5181313
    typ 3_________________________________________________
    Cosmic = 987654321987654321 typ 3
    square = 993807990
    PL [1, 3, 7, 11, 13, 17, 19, 52579, 379721](*) = 19365771019365771
    (ip*dv(axe)) = 51 * 19365771019365771 typ 3*3
    (ip(sup)*dv(inf)) = 987654321 * 1000000001 typ 3*5
    # F break maxFermiers(Cosmic): 987654321987654321

    Cosmic 645231875461353 typ 3
    cartyp6 25401414
    [1, 3, 17](*) = 51
    (ip(axe)*dv) = 51 * 12651605401203 typ 3*3
    (ip(sup)*dv(inf)) = 459 * 1405733933467° typ 3*1
    C len(haut) horscourse 459
    W break cartyp6 25401403
    typ 4_________________________________________________
    Cosmic = 846465432165442 typ 4
    square = 29094078
    PL [1, 2, 17, 53, 6067](*) = 10932734
    (ip(sup)*dv(inf)) = 10932734 * 77424863 typ 2*5
    CoMulti maxFermiers = 10932734
    C break CaxeP 373523

    Cosmic 65315487956524 typ 4
    cartyp6 8081799
    [1, 2, 13, 31](*) = 806
    (ip(axe)*dv) = 806 * 81036585554 typ 2*2
    (ip(sup)*dv(inf)) = 1612 * 40518292777 typ 4*1
    C len(haut) horscourse 1612
    W break cartyp6 8081791
    typ 5_________________________________________________
    Cosmic = 465321564589739 typ 5
    square = 21571313
    PL [1, 11, 13, 429797, 7571009](*) = 465321564589739
    (ip(min)*dv(sup)) = 1 * 465321564589739 typ 1*5
    (ip(sup)*dv(inf)) = 7571009 * 61460971 typ 5*1
    # F break maxFermiers(Cosmic): 465321564589739

    Cosmic 546897512558795 typ 5
    cartyp6 23385840
    [1, 5, 47, 1709](*) = 401615
    (ip(sup)*dv(inf)) = 401615 * 1361745733 typ 5*1
    C len(haut) horscourse 401615
    W break cartyp6 23385829



    (ip*dv) =
    (ip*dv) =
    (ip*dv) =
    (ip*dv) =
    (ip*dv) =



    Cosmic = 357951258456 typ 0
    square = 598290
    PL [1, 2, 3, 11, 11587, 117017](*) = 89487814614
    (ip*dv(axe)) = 4 * 89487814614 typ 4*0
    (ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0
    # F break maxFermiers(Cosmic): 357951258456
    1287187 1355875979 14914635769
    Premiers ( 32 )ex
    [1, 2, 3, 11, 11587, 117017]
    1 * 357951258456 typ 1*0
    2 * 178975629228 typ 2*0
    3 * 119317086152 typ 3*2
    4 * 89487814614 typ 4*0
    6 * 59658543076 typ 0*4
    8 * 44743907307 typ 2*3
    11 * 32541023496 typ 5*0 1287187(11) 14914635769(11)
    12 * 29829271538 typ 0*2
    22 * 16270511748 typ 4*0
    24 * 14914635769 typ 0*1 1 * 14914635769 typ 1*1
    33 * 10847007832 typ 3*4
    44 * 8135255874 typ 2*0
    66 * 5423503916 typ 0*2
    88 * 4067627937 typ 4*3
    132 * 2711751958 typ 0*4
    264 * 1355875979 typ 0*5 1 * 1355875979 typ 1*5
    11587 * 30892488 typ 1*0 1355875979(11587)
    23174 * 15446244 typ 2*0
    34761 * 10297496 typ 3*2
    46348 * 7723122 typ 4*0
    69522 * 5148748 typ 0*4
    92696 * 3861561 typ 2*3
    117017 * 3058968 typ 5*0 1287187(117017) 1355875979(117017)
    127457 * 2808408 typ 5*0
    139044 * 2574374 typ 0*2
    234034 * 1529484 typ 4*0
    254914 * 1404204 typ 4*0
    278088 * 1287187 typ 0*1 1 * 1287187 typ 1*1
    351051 * 1019656 typ 3*4
    382371 * 936136 typ 3*4
    468068 * 764742 typ 2*0
    509828 * 702102 typ 2*0
    nphullmen_4.py En:
    0.39316320419311523
    _______________________________PUIS____________________________________
    Ce corps de texte rassemble les cas rencontrés avec les multiples communs.
    Ils sont assez nombreux pour les noter sur cette page.
    Analyses sur les termes communs: Le couplage voisin de la racine carrée.
    Services rendus par des reports importants et formels.
    Exemple type d'analyse:

    CAS FERMIER = COSMIC
    typ 0_________________________________________________
    Cosmic = 357951258456 typ 0
    square = 598290
    PL [1, 2, 3, 11, 11587, 117017](*) = 89487814614
    (ip*dv(axe)) = 4 * 89487814614 typ 4*0
    (ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0
    # F break maxFermiers(Cosmic): 357951258456

    La table des nombres premiers et multiples communs du nombre entier.
    Les premiers se multiplient pour donner un produit :hautmulti:.
    _1*2*3*11*11587*117017=89487814614_
    Selon le tempérament des communs variant de nombre en nombre.
    H :hautmulti: = Nombre Entier.
    H :hautmulti: = Niveau bas du couple voisin à la racine carrée (n**.5).
    H :hautmulti: = Niveau moyen des éléments de couple, comme ci-dessus.

    L'utilisation des lecteurs typés itératifs dédiés aux communs.
    Les communs des lecteurs sont préalablement premiers, d'où un tri.
    Les nombres premiers produisent aussi une liste de communs.

    C :premiers Ces trois tables évoluent à chaque nouveau premier.
    F :fermiers Elles produisent les nombres communs relatifs.
    R :ramieres Les limites relatives sont significatives.
    C :premiers*) = H :hautmulti: (89487814614).

    Cosmic > H :hautmulti Le haut multiple est à moyen niveau de couple.
    _(ip*dv(axe)) = 4 * 89487814614 typ 4*0_

    F :fermiers: = Cosmic (357951258456)| Nombre égale le max(communs).
    _# F break maxFermiers(Cosmic): 357951258456_

    F :fermiers Au centre des communs, le couple voisin de la racine carrée.
    _(ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0_

    CAS FERMIER != COSMIC
    typ 1_________________________________________________
    Cosmic = 84269713568423971 typ 1
    square = 290292462
    PL [1, 7, 23, 151](*) = 24311
    (ip(axe)*dv) = 24311 * 3466320331061 typ 5*5
    (ip(sup)*dv(inf)) = 170177 * 495188618723° typ 5*5
    CoMulti maxFermiers = 170177
    C break CaxeP 23623665

    H :hautmulti Objet inférieur de couple (24311)
    _(ip(axe)*dv) = 24311 * 3466320331061 typ 5*5_

    F :fermiers Objet inférieur de couple voisin :square: (170177)
    _(ip(sup)*dv(inf)) = 170177 * 495188618723° typ 5*5_

    Ici les communs ne sont pas parvenus à la valeur du nombre :Cosmic:
    Aidé par l'objet supérieur de couple et informateur d'état (ip(sup)*dv(inf)).
    Terminant la liste des communs, par un objet supérieur premier (495188618723).












    """

    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  11. #51
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut

    Ce qui m'étonne c'est que dans une confusion quasi insoutenable, le phénomène du déjà codé m'aide à me sortir des mauvais pas. Certes après une mûre maturité visionnaire, ou pas. Ainsi que de toutes les zizanies écrites à la va vite, pour obtenir Le Résultat même si le mélange ne fait pas la mayonnaise, il se pourrait bien avoir sauvé la situation numérale en cherchant Les Résultats. Et que la mélasse encore visuelle dans le code et à savoir si certaines portions ne seront jamais utilisées. Car pour comprendre les nombres, il faut presque les écouter un par un. Chacun a son histoire, même s'ils sont communs.
    Sauf qu'en général, il vaut mieux lire entre les lignes. Pour moi cet évènement est nouveau, pour vous je ne sais pas. Puis à terme il présente une définition des liens entre les nombres (fréquences, ondes, unités...). Certainement pas du hasard, et combien d'utilisation virtuelle

    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphullmen_4a Ce 17 novembre 2017
    """Version public"""
    import time
    time_ = time.time()
    nombre = 987654321010123456789
    # :breakComm: printage communs
    breakComm = 1
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    hautmulti_ = [1]
    p1 = 7
    p5 = 11
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
     
    def compare(c):
        hautmulti_[0] = 1
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
            for haut in hautniveau[1:]:
                if not c % haut:
                    break
            else:
                hautniveau.append(c)
                for h in hautniveau:
                    hautmulti_[0] *= h
                if len(hautniveau):
                    for c1 in sorted(hautniveau):
                        for c2 in horscourse:
                            c12 = c1 * c2
                            if not nombre % c12 \
                                    and c12 not in horscourse:
                                if c12 <= carre:
                                    horscourse.append(c12)
                                    horscourse.sort()
                    cartyp6[0] = int((nombre//max(horscourse))**.5)
                    # Terme commun     
                    if max(horscourse) <= carre:
                        if hautmulti_[0]:
                            hdv = hautmulti_[0] * hautniveau[1]
                            how = nombre // hautmulti_[0]
                            if hdv >= carre and not nombre % hdv:
                                hip = nombre // hdv
                                if hip not in hautniveau:
                                    compare(hip)
                            if how not in hautniveau \
                               and 1 < how <= carre:
                                compare(how)
                    # Terme racine        
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                    elif hautmulti_[0] > (nombre // hautniveau[1]):
                        hautmulti_[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    """Hauts niveaux premiers: cartyp6
    Chercher dans l'alignement des nombres premiers"""
    while p1 <= cartyp6[0]:
        if hautmulti_[0] == 0:
            break
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
                horscourse.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
                horscourse.append(p5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
        p1 += 6
        p5 += 6
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    if max(horscourse) > carre:
        hi = len(horscourse) // 2
    else:
        hi = len(horscourse)
    hautniveau.sort()
    print('Premiers (', hi, ')ex\n', hautniveau)
    for i in sorted(horscourse):
        print('{} * {} typ {}*{}'
              .format(i, nombre // i, i % 6, (nombre // i) % 6))
        if breakComm == 0:
            break
    print('nphullmen_4a.py En: \n', time.time() - time_)
    print('', )
    Bien qu'à mi-chemin conduisant à un autre genre de développement, concrétisant le traitement plus sobrement. Ce qui au départ est difficile, facilite l'évolution qui se voue à la perfection personnelle de l'auteur.
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  12. #52
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut classnph de ouf

    Bonjour je viens juste de terminer une partie de restructuration se situant au niveau de la compréhension des lectures.
    À savoir, quels sont les signes distinctifs liés aux nombres, ce phénomène est visible lorsqu'on poursuit les différents "break" d'arrêts.

    Ce résultat n'est en aucun cas la mouture finale, selon que le sujet soit traité plus simplement. Il faut prendre conscience que le niveau d'effort face à l'erreur est important, signifiant une parfaite concentration sur la solution codée. Les divergences suivantes aux diverses cohérences relatives à l'état de la communauté des premiers multiples communs, m'ont aidées à établir plusieurs points logiques. Et qui dit plusieurs, dit nombreux de manière à former un groupe de traitements logiques. De pas à pas la situation s'éclaircit, jusqu'à voir un certain ciel dégagé de tous ces moches nuages.

    Le code de nphullmen_5a.py

    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 première. En Général Python
    # Origine : nphermier_9a Du 8 octobre 2017
    # MusicAtoumic nphullmen_5a Ce 26 novembre 2017
    """Version public"""
    import time
    time_ = time.time()
    nombre = 1234567890987654321
    # :breakComm: printage communs
    breakComm = 1
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    topsmutli_ = []
    hautmulti_ = [1]
    c12tableau = []
    p1 = 7
    p5 = 11
    print('Nombre =', nombre, 'typ', nombre % 6)
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
    borne = int(carre ** .9)
    print('cartyp6 %s borne %s' % (cartyp6, borne))
     
    def compare(c):
        hautmulti_[0] = 1
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
                horscourse.sort()
            for haut in hautniveau[1:]:
                if not c % haut:
                    break
            else:
                hautniveau.append(c)
                for h in hautniveau:
                    hautmulti_[0] *= h
                if len(hautniveau):
                    for c1 in sorted(hautniveau):
                        for c2 in horscourse:
                            c12 = c1 * c2
                            if not nombre % c12 \
                                    and c12 not in horscourse:
                                if c12 <= carre:
                                    horscourse.append(c12)
                                    horscourse.sort()
                                elif c12 not in c12tableau:
                                    c12tableau.append(c12)
                                    c12tableau.sort()
                    if c12tableau:
                        for ctab in c12tableau:
                            iptab = nombre // ctab
                            if iptab not in horscourse:
                                compare(iptab)
                    cartyp6[0] = int((nombre // max(hautniveau)) ** .5)
                    # Terme commun     
                    if max(horscourse) <= carre:
                        if hautmulti_[0]:
                            hdv = hautmulti_[0] * hautniveau[1]
                            if hdv >= carre and not nombre % hdv:
                                hip = nombre // hdv
                                if hip not in hautniveau:
                                    compare(hip)
                    if hautmulti_[0] != 0:
                        # Terme racine
                        if hautmulti_[0] == nombre:
                            hautmulti_[0] = 0
                        elif hautmulti_[0] * hautniveau[1] >= carre \
                                and hautmulti_[0] == max(hautniveau):
                            hautmulti_[0] = 0
                        elif hautmulti_[0] * hautniveau[1] >= nombre:
                            hautmulti_[0] = 0
                        elif max(horscourse) == nombre:
                            hautmulti_[0] = 0
                        else:
                            if len(hautniveau) > 2:
                                dvinf = nombre // max(horscourse)
                                ipant = horscourse[-2] * dvinf
                                ipsup = nombre // hautniveau[1]
                                for ii in range(max(hautniveau),
                                                int(borne ** .5)):
                                    if not dvinf % ii:
                                        if ii not in horscourse:
                                            compare(ii)
                                        break
                                else:
                                    if ipant == ipsup:
                                        hautmulti_[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers"""
    while p1 <= cartyp6[0]:
        if hautmulti_[0] == 0:
            break
        elif p1 >= cartyp6[0]:
            break
        elif len(hautniveau) < 2 and p1 >= int(borne**.7):
            break
        # Lecteurs en action
        if not nombre % p1 and p1 not in hautniveau \
                and p1 not in horscourse:
            compare(p1)
        if not nombre % p5 and p5 not in hautniveau \
                and p5 not in horscourse:
            compare(p5)
        p1 += 6
        p5 += 6
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    if max(horscourse) > carre:
        hi = len(horscourse) // 2
    else:
        hi = len(horscourse)
    hautniveau.sort()
    print('Premiers (', hi, ')ex\n', hautniveau)
    for i in sorted(horscourse):
        if breakComm == 0:
            ha = horscourse[hi - 1]
            hu = horscourse[0]
            print('Duos (inf)*(sup)|(sup)*(inf) \n{} * {} Types {}&{}'
                  .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
            print('    {} * {} Types {}&{}'
                  .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
            break
        else:
            print('{} * {} Types {}&{}'
                  .format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphullmen_5a.py En: \n', time.time() - time_)
    print('', )
    L'affichage des communs et un temps d'exécution rassurant

    Nombre = 1234567890987654321 typ 3
    cartyp6 [1111111106] borne 138414548
    Premiers ( 24 )ex
    [1, 3, 7, 19, 928163]
    1 * 1234567890987654321 Types 1&3
    3 * 411522630329218107 Types 3&3
    7 * 176366841569664903 Types 1&3
    9 * 137174210109739369 Types 3&1
    19 * 64977257420402859 Types 1&3
    21 * 58788947189888301 Types 3&3
    57 * 21659085806800953 Types 3&3
    63 * 19596315729962767 Types 3&1
    133 * 9282465345771837 Types 1&3
    171 * 7219695268933651 Types 3&1
    399 * 3094155115257279 Types 3&3
    1197 * 1031385038419093 Types 3&1
    928163 * 1330119699867 Types 5&3
    2784489 * 443373233289 Types 3&3
    6497141 * 190017099981 Types 5&3
    8353467 * 147791077763 Types 3&5
    17635097 * 70006299993 Types 5&3
    19491423 * 63339033327 Types 3&3
    52905291 * 23335433331 Types 3&3
    58474269 * 21113011109 Types 3&5
    123445679 * 10000899999 Types 5&3
    158715873 * 7778477777 Types 3&5
    370337037 * 3333633333 Types 3&3
    1111011111 * 1111211111 Types 3&5
    nphullmen_5a.py En:
    3.5613858699798584
    Bye
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  13. #53
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut

    Citation Envoyé par toumic Voir le message
    Bonjour je viens juste de terminer une partie de restructuration se situant au niveau de la compréhension des lectures.
    À savoir, quels sont les signes distinctifs liés aux nombres, ce phénomène est visible lorsqu'on poursuit les différents "break" d'arrêts.

    Ce résultat n'est en aucun cas la mouture finale, selon que le sujet soit traité plus simplement. Il faut prendre conscience que le niveau d'effort face à l'erreur est important, signifiant une parfaite concentration sur la solution codée. Les divergences suivantes aux diverses cohérences relatives à l'état de la communauté des premiers multiples communs, m'ont aidées à établir plusieurs points logiques. Et qui dit plusieurs, dit nombreux de manière à former un groupe de traitements logiques. De pas à pas la situation s'éclaircit, jusqu'à voir un certain ciel dégagé de tous ces moches nuages.

    Le code de nphullmen_5a.py
    Bye
    Le zéro n'est pas encore géré, et bien ?

    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
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Origine : nphermier_9a Du 8 octobre 2017
    # MusicAtoumic nphullmen_6 Ce 5 décembre 2017
    """Version public"""
    import time
    time_ = time.time()
    nombre = 2564
    # :breakComm: printage communs
    breakComm = 1
    carre = int(nombre ** .5)
    hautniveau = []
    if nombre == 0:
        horscourse = [0]
    else:
        horscourse = []
    hautmulti_ = [1]
    horspluri_ = [0]
    c12tableau = []  # Liste communs dv
    p1 = [7]
    p5 = [11]
    q1 = [0]
    q5 = [0]
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
    borne = int(carre ** .9933)
     
    def forme15(r1_, rng_, r6_):
        if r6_ == 1:
            if r1_ > 0:
                p1[0] = rng_
            else:
                q1[0] = rng_
        else:
            dfo_ = r6_ - 1
            if r1_ > 0:
                p1[0] = rng_ - dfo_
            else:
                q1[0] = rng_ - dfo_
        if r1_ > 0:
            p5[0] = p1[0] - 2
        else:
            q5[0] = q1[0] - 2
     
    forme15(0, borne, borne % 6)
     
    def compare(c):
        hautmulti_[0] = 1
        didi = [c]
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
                horscourse.sort()
            sqc = int(c ** .5)
            for dd in range(2, sqc):
                if not c % dd:
                    didi.append(dd)
                    dddv = c // dd
                    didi.append(dddv)
                    didi.sort()
                    break
            for di in didi:
                c = di
                for haut in hautniveau[1:]:
                    if not c % haut:
                        break
                else:
                    hautniveau.append(c)
            for h in hautniveau:
                hautmulti_[0] *= h
            if hautmulti_[0] != 0:
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        if iptab not in horscourse:
                            for hh in hautniveau[1:]:
                                if not iptab % hh:
                                    break
                            else:
                                compare(iptab)
                    if hautmulti_[0]:
                        c12ip = nombre // max(hautniveau)
                        if max(c12tableau) > c12ip:
                            hautmulti_[0] = 0
                for h in horscourse:
                    if horspluri_[0] <= nombre:
                        horspluri_[0] += h
                cartyp6[0] = int((nombre // max(hautniveau)) ** .5)
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        hdv = hautmulti_[0] * hautniveau[1]
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            if hip not in hautniveau:
                                compare(hip)
                if hautmulti_[0]:
                    # Terme racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                    else:
                        ppp = 0
                        png = nombre // max(hautniveau)
                        dvinf = nombre // max(horscourse)
                        ipsup = dvinf // max(horscourse)
                        if len(hautniveau) > 2:
                            if ipsup >= carre:
                                rng = int(max(horscourse) ** 1.613)
                                for ii in range(rng, int(dvinf ** .5)):
                                    if not dvinf % ii:
                                        if ii not in horscourse:
                                            compare(ii)
                                            break
                                        if ii > horspluri_[0]:
                                            ppp = dvinf
                                            wu[0] = 0
                                            forme15(1, ppp, ppp % 6)
                                            break
                                    for iii in horscourse[1:]:
                                        if not ppp % iii:
                                            break
                                    else:
                                        hautmulti_[0] = 0
                                        break
                            else:
                                hautmulti_[0] = 0
                        wu[0] = 0
                        if hautmulti_[0]:
                            if max(hautniveau) > int(borne ** .3):
                                rng = int(png ** .4958)
                                r6 = rng % 6
                                forme15(1, rng, r6)
                                wu[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers"""
    wu = [0]
    while p1[0] <= cartyp6[0]:
        while wu[0] < 1:  # Simple effet de boucle
            cartyp6[0] = int((nombre // max(hautniveau)) ** .5)
            wu[0] += 1
        if hautmulti_[0] == 0:
            break
        elif p1[0] >= q1[0]:
            break
        elif p1[0] >= cartyp6[0]:
            break
        elif len(hautniveau) < 2 and p1[0] >= borne:
            break
        # Lectures
        if not nombre % p1[0] and p1[0] not in hautniveau \
                and p1[0] not in horscourse:
            compare(p1[0])
        if not nombre % p5[0] and p5[0] not in hautniveau \
                and p5[0] not in horscourse:
            compare(p5[0])
        if not nombre % q1[0] and q1[0] not in hautniveau \
                and q1[0] not in horscourse:
            compare(q1[0])
        if not nombre % q5[0] and q5[0] not in hautniveau \
                and q5[0] not in horscourse:
            compare(q5[0])
        p1[0] += 6
        p5[0] += 6
        q1[0] -= 6
        q5[0] -= 6
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    if max(horscourse) > carre:
        hi = len(horscourse) // 2
    else:
        hi = len(horscourse)
    hautniveau.sort()
    print('Premiers (', hi, ')ex\n', hautniveau)
    for i in sorted(horscourse):
        if breakComm == 0:
            ha = horscourse[hi - 1]
            hu = horscourse[0]
            print('Duos (inf)*(sup)|(sup)*(inf) \n{} * {} Types {}&{}'
                  .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
            print('    {} * {} Types {}&{}'
                  .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
            break
        else:
            print('{} * {} Types {}&{}'
                  .format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphullmen_6.py En: \n', time.time() - time_)
    print('', )
    * * * Erreur rencontrée (conseil = travailler avec 2 calculatrices)
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  14. #54
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Alors, Python code coule de source

    Il est toujours agréable d'affiner le code, et je sais qu'il germe un traitement visant à raccourcir le temps des itérations des lecteurs. Aidé par la consistence même des nombres premiers multiples communs, et de part la position occupée des ces derniers. Nous avons l'image des briques et de leurs architecture, les racines carrées aidant à positionner les lectures forment une sorte d'entonnoir et justement éloigné des racines "réelles". Où la racine réelle est n**.5, et l'entonnoir n**.4.

    Dans ce contexte commun, les associations symbolisent des structures propres à la nature de la composition des nombres entiers. Je vous en ai déjà assez dit pour le moment, le moment du code est là
    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
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphullmen_6a Ce 10 décembre 2017
    """Python Compulsion Commune"""
    import time
    time_ = time.time()
     
    def zero(z):
        if z == 1:
            z = 0
            print('Premiers (', z, ')ex\n', '[0]')
            print('{} * {} Types {}&{}'
                  .format(z, z, z % 6, z % 6))
            print('nphullmen_6x.py En: \n', time.time() - time_)
        else:
            print('nphullmen_6x.py En: \n', time.time() - time_)
     
    # _____________________
    # :nombre: objet unique
    nombre = 654321547654321547
    # :breakComm: printage communs
    breakComm = 1
    # :zero: instruction zéro
    if nombre == 0:
        zero(breakComm)
    # :carre: service axial
    carre = int(nombre ** .5)
    hautniveau = []  # Liste premiers
    horscourse = []  # Liste communs ip&dv
    hautmulti_ = [1]  # Mul.hautniveau
    horsmulti_ = [1]  # Mul.horscourse
    c12tableau = []  # Liste communs dv
    # Lecteurs initiaux
    p1 = [7]
    p5 = [11]
    q1 = [0]
    q5 = [0]
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
    borne = int(cartyp6[0] ** .999)
    borne = [borne]
     
    def forme15(r1_, rng_, r6_):
        """Positionnement des Lecteurs (bas/hauts)
            P1: Point (+6) Type (1)
                Position inférieure :ip: Inf.carre
            Q1: Point (-6) Type (5)
                Position supérieure :dv: Sup.carre"""
        if r6_ == 1:
            if r1_ > 0:
                p1[0] = rng_
            else:
                q1[0] = rng_
        else:
            dfo_ = r6_ - 1
            if r1_ > 0:
                p1[0] = rng_ - dfo_
            else:
                q1[0] = rng_ - dfo_
        if r1_ > 0:
            p5[0] = p1[0] - 2
        else:
            q5[0] = q1[0] - 2
     
    if nombre != 0:
        forme15(0, borne[0], borne[0] % 6)
     
    def compare(c):
        """Réception et traitement (c)"""
        hautmulti_[0] = 1
        didi = [c]
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
                horscourse.sort()
            sqc = int(c ** .5)
            for dd in range(2, sqc):
                if not c % dd:
                    didi.append(dd)
                    dddv = c // dd
                    didi.append(dddv)
                    didi.sort()
                    break
            for di in didi:
                c = di
                for haut in hautniveau[1:]:
                    if not c % haut:
                        break
                else:
                    hautniveau.append(c)
            # Production haut niveau
            for hha in hautniveau:
                hautmulti_[0] *= hha
            if hautmulti_[0] != 0:
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        # Séparation :carre:
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        # :ctab: Occurence :c12:
                        if iptab not in horscourse:
                            for hh in hautniveau[1:]:
                                if not iptab % hh:
                                    break
                            else:
                                compare(iptab)
                    if hautmulti_[0]:
                        c12ip = nombre // max(hautniveau)
                        # :c12ip: Sup.carre(dv) de Max.premier(ip)
                        if max(c12tableau) > c12ip:
                            hautmulti_[0] = 0
                if hautmulti_[0]:
                    horsmulti_[0] = 1
                    # Production hors course
                    for hha in horscourse:
                        if horsmulti_[0] <= nombre:
                            horsmulti_[0] *= hha
                    cartyp6[0] = int((nombre // max(hautniveau)) ** .499)
                    brn = int(cartyp6[0] ** .5)
                    borne[0] = brn
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        hdv = hautmulti_[0] * hautniveau[1]
                        # :hdv: Son.carre(dv) par Min.hautniveau
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            # :hip: Son(ip) du Son.carre(dv)
                            if hip not in horscourse:
                                compare(hip)
                if hautmulti_[0]:
                    # Termes racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                    else:
                        # Différentiel comparatif
                        dvinf = nombre // max(horscourse)
                        ipsup = dvinf // max(horscourse)
                        if len(hautniveau) > 2:
                            if ipsup >= carre:
                                rng = int(
                                    (nombre // max(hautniveau)) ** .4534)
                                r6 = rng % 6
                                forme15(0, rng, r6)
                            else:
                                sqinf = int(dvinf ** .5) + 1
                                for e in range(max(hautniveau), sqinf):
                                    if not dvinf % e:
                                        if e % 6 in (1, 5) \
                                                and e not in horscourse:
                                            compare(e)
                                            break
                                else:
                                    hautmulti_[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers
    Composition des hors course"""
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    if horscourse:
        for h in horscourse:
            for o in horscourse:
                oh = h * o
                if not nombre % oh and oh not in horscourse:
                    compare(oh)
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers
    Condition évolutive des lecteurs"""
    while p1[0] <= cartyp6[0]:
        if hautmulti_[0] == 0:
            break
        elif p1[0] > q1[0]:
            break
        elif p1[0] >= cartyp6[0]:
            break
        elif len(hautniveau) < 3 and p1[0] >= int(borne[0] ** .5):
            if hautmulti_[0] == 0:
                dvhors = nombre // max(horscourse)
                sqhors = int(dvhors ** .5) + 1
                for ds in range(max(hautniveau), int(sqhors ** .6)):
                    if not dvhors % ds and ds not in horscourse:
                        compare(ds)
                else:
                    break
        # Lectures
        if not nombre % p1[0] and p1[0] not in hautniveau \
                and p1[0] not in horscourse:
            compare(p1[0])
        if not nombre % p5[0] and p5[0] not in hautniveau \
                and p5[0] not in horscourse:
            compare(p5[0])
        if not nombre % q1[0] and q1[0] not in hautniveau \
                and q1[0] not in horscourse:
            compare(q1[0])
        if not nombre % q5[0] and q5[0] not in hautniveau \
                and q5[0] not in horscourse:
            compare(q5[0])
        p1[0] += 6
        p5[0] += 6
        q1[0] -= 6
        q5[0] -= 6
    if nombre != 0:
        """Désigne la communauté:
        Les nombres premiers associés :hautniveau:
        Produisent la communauté des multiples communs"""
        if max(horscourse) > carre:
            hi = len(horscourse) // 2
        else:
            hi = len(horscourse)
        hautniveau.sort()
        print('Premiers (', hi, ')ex\n', hautniveau)
        for i in sorted(horscourse):
            if breakComm == 0:
                ha = horscourse[hi - 1]
                hu = horscourse[0]
                print('Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} Types {}&{}'
                      .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
                print('  {} * {} Types {}&{}'
                      .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
                break
            else:
                print('{} * {} Types {}&{}'
                      .format(i, nombre // i, i % 6, (nombre // i) % 6))
        print('nphullmen_6a.py En: \n', time.time() - time_)
        print('', )
    Et de son résultat, où une grande échelle est entamée, autant pour la technique relationnelle

    \nphermier\nphumier\nphullmen_6a.py
    W break hautmulti_ [0]
    Premiers ( 32 )ex
    [1, 11, 23, 5387, 120157, 246107909, 909090909090909091]
    1 * 36639493274782624133663949327478262413 Types 1&1
    11 * 3330863024980238557605813575225296583 Types 5&5
    23 * 1593021446729679310159302144672967931 Types 5&5
    253 * 144820131520879937287209285879360721 Types 1&1
    5387 * 6801465244993990000680146524499399 Types 5&5
    59257 * 618315022272180909152740593136309 Types 1&1
    120157 * 304930160330090000030493016033009 Types 1&1
    123901 * 295715880217130000029571588021713 Types 1&1
    1321727 * 27720923666371818184590274184819 Types 5&5
    1362911 * 26883261837920909093597417092883 Types 5&5
    2763611 * 13257833057830000001325783305783 Types 5&5
    30399721 * 1205257550711818181938707573253 Types 1&1
    246107909 * 148875724570000000014887572457 Types 5&5
    647285759 * 56604819070000000005660481907 Types 5&5
    2707186999 * 13534156779090909092262506587 Types 1&1
    5660481907 * 6472857590000000000647285759 Types 1&1
    7120143349 * 5145892642727272727787316537 Types 1&1
    14887572457 * 2461079090000000000246107909 Types 1&1
    62265300977 * 588441599090909090967935069 Types 5&5
    163763297027 * 223734462727272727295100719 Types 5&5
    1325783305783 * 27636110000000000002763611 Types 1&1
    14583616363613 * 2512373636363636363887601 Types 5&5
    29571588021713 * 1239010000000000000123901 Types 5&5
    30493016033009 * 1201570000000000000120157 Types 5&5
    325287468238843 * 112637272727272727283991 Types 1&1
    335423176363099 * 109233636363636363647287 Types 1&1
    680146524499399 * 53870000000000000005387 Types 1&1
    7481611769493389 * 4897272727272727273217 Types 5&5
    159302144672967931 * 230000000000000000023 Types 1&1
    909090909090909091 * 40303442602260886543 Types 1&1
    1752323591402647241 * 20909090909090909093 Types 5&5
    3663949327478262413 * 10000000000000000001 Types 5&5
    nphullmen_6a.py En:
    284.5729763507843
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  15. #55
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut nphullmen_6x.py

    Bonjour
    Quand on ne me connaît pas, on se demande toujours : Mais qu'est-ce qu'il raconte ?

    Heureusement pour nous, nous n'avons pas besoin de nous comprendre entièrement, et pour le cas qui me concerne ce sera partiellement. Tout définir est un travail de longue haleine, et puisque je passe mon temps à coder ce simple petit programme qui m'accapare. Jusqu'à aujourd'hui, et encore une fois, j'exclame mon plaisir commun à chacun d'entre nous, puisse profiter de ce code si tel n'est pas le cas

    Comme dit, les nombres forment un rassemblement invraisemblable. Ils sont difficiles à cerner, et toutes ces avancées amènent à des bonnes compréhensions.
    Bonne continuation à tous ceux qui cheminent parmi l'univers des nombres...

    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
    379
    380
    381
    382
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Objet : Apprendre par la pratique
    # MusicAtoumic nphullmen_8x Ce 14 décembre 2017
    """Pyhton Compulsion Commune"""
    import time
    time_ = time.time()
     
    def zero(z):
        if z == 1:
            z = 0
            print('Premiers (', z, ')ex\n', '[0]')
            print('{} * {} Types {}&{}'
                  .format(z, z, z % 6, z % 6))
            print('nphullmen_6x.py En: \n', time.time() - time_)
        else:
            print('nphullmen_6x.py En: \n', time.time() - time_)
     
    # 999888777666555000111222333444555 1304562926286024619985807821
    # 1234567898765432112345678987654321
    # 999888777666555666777888999 987898765456543212321
    # 999888777666555444333222111 222557130146747222557130146747
    # _____________________ 111222333222111000111222333222111
    # :nombre: objet unique
    nombre = 222557130146747222557130146747
    print('Nombre =', nombre, '; typ =', nombre % 6)
    # :breakComm: printage communs
    breakComm = 0
    # :zero: instruction zéro
    if nombre == 0:
        zero(breakComm)
    elif nombre < 0:
        nombre = abs(nombre)
    # :carre: service axial
    carre = int(nombre ** .5)
    hautniveau = []  # Liste premiers
    horscourse = []  # Liste communs ip&dv
    hautmulti_ = [1]  # Mul.hautniveau
    horsmulti_ = [1]  # Mul.horscourse
    c12tableau = []  # Liste communs dv
    # Lecteurs initiaux
    p1 = [7]
    p5 = [11]
    m1 = [0]
    m5 = [0]
    d1 = [0]
    d5 = [0]
    q1 = [0]
    q5 = [0]
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
    borne = int(cartyp6[0] ** .992)
    borne = [borne]
    print('cartyp6 = %s ; borne = %s' % (cartyp6, borne))
     
    def forme15(rng_, r6_,mng_, m6_):
        """Positionnement des Lecteurs (bas/hauts)
            P1: Point (+6) Type (1)
                Position inférieure :ip: Inf.carre
            Q1: Point (-6) Type (5)
                Position supérieure :dv: Sup.carre"""
        if r6_ == 1:
            q1[0] = rng_
        else:
            dfo_ = r6_ - 1
            q1[0] = rng_ - dfo_
     
        if m6_ == 1:
            m1[0] = mng_
            d1[0] = mng_
        else:
            dfo_ = m6_ - 1
            m1[0] = mng_ - dfo_
            d1[0] = mng_ - dfo_
     
     
        # Position P5
        p5[0] = p1[0] - 2
        # Position Q5
        q5[0] = q1[0] - 2
        # Position M5
        m5[0] = m1[0] - 2
        d5[0] = d1[0] - 2
        print(' f15 p1, typ', p1[0], p1[0] % 6)
        print(' f15 d1, typ', d1[0], d1[0] % 6)
     
    if nombre != 0:
        mib0 = borne[0] // 2
        forme15(borne[0], borne[0] % 6, mib0, mib0 % 6)
     
    def compare(c):
        """Réception et traitement (c)"""
        hautmulti_[0] = 1
        didi = [c]
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
                horscourse.sort()
            sqc = int(c ** .5)
            for dd in range(2, sqc):
                if not c % dd:
                    didi.append(dd)
                    dddv = c // dd
                    didi.append(dddv)
                    didi.sort()
                    break            
            # Priorité :didi:
            print('C didi', didi)
            for di in didi:
                c = di
                for haut in hautniveau[1:]:
                    if not c % haut:
                        break
                else:
                    hautniveau.append(c)
            # Production haut niveau
            for hha in hautniveau:
                hautmulti_[0] *= hha
            if hautmulti_[0] != 0:
                print('Oniveau =', sorted(hautniveau))
                print('Omulti_ =', hautmulti_)
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        # Séparation :carre:
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    print('C max: c12 =', max(c12tableau))
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        # :ctab: Occurence :c12:
                        if iptab not in horscourse:
                            for hh in hautniveau[1:]:
                                if not iptab % hh:
                                    break
                            else:
                                print('C c12 compare: iptab =', iptab)
                                compare(iptab)
                    if hautmulti_[0]:
                        c12ip = nombre // max(hautniveau)
                        # :c12ip: Sup.carre(dv) de Max.premier(ip)
                        print('C c12ip, max(c12)', c12ip, max(c12tableau))
                        if max(c12tableau) > c12ip:
                            hautmulti_[0] = 0
                            print('C BREAK max(c12)', max(c12tableau))
                if hautmulti_[0]:
                    horsmulti_[0] = 1
                    # Production hors course
                    for hho in horscourse:
                        if horsmulti_[0] <= nombre:
                            horsmulti_[0] *= hho
                    print('C coms(', len(horscourse), ')ex HORS(',
                          max(horscourse), ')')
                    print('C  ****HORSmulti_', horsmulti_)
                    cartyp6[0] = int((nombre // max(hautniveau)) ** .499)
                    brn = int(cartyp6[0] ** .5)
                    borne[0] = brn
                    print('C cartyp6 =', cartyp6, 'borne =', borne)
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        print('Cm if hautmulti', hautmulti_[0])
                        hdv = hautmulti_[0] * hautniveau[1]
                        # :hdv: Son.carre(dv) par Min.hautniveau
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            # :hip: Son(ip) du Son.carre(dv)
                            if hip not in horscourse:
                                print('Cm compare: hip =', hip)
                                compare(hip)
                print('C')
                if hautmulti_[0]:
                    # Termes racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                        print('E BREAK multi_==', nombre)
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                        print('E BREAK multi*min(c)', hautmulti_)
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                        print('E BREAK multi*min(n)', hautmulti_)
                    elif (nombre // hautmulti_[0]) <= max(hautniveau):
                        hautmulti_[0] = 0
                        print('E BREAK n/multi <= max(haut)', hautmulti_)
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                        print('E BREAK hors(nombre)', nombre)
                    else:
                        # Différentiel comparatif
                        dvinf = nombre // max(horscourse)
                        ipsup = dvinf // max(horscourse)
                        sqinf = int(dvinf ** .5)
                        print('E (,sqinf)', sqinf)
                        print('E nombre//max(hors) dvinf =', dvinf)
                        print('E dvinf//max(hors) ipsup =', ipsup)
                        if len(hautniveau) > 2:
                            typ = 0
                            if ipsup >= carre:
                                if borne[0] == int(carre ** .992):
                                    bord = int(borne[0] ** .7)
                                else:
                                    bord = int(carre ** .5)
                                rng = bord
                                r6 = rng % 6
                                print('E rng', rng,
                                      'dv*.5', int(dvinf ** .499))
                                mib1 = borne[0] // 2
                                forme15(rng, r6, mib1, mib1 % 6)
                            else:
                                print('E else(dvinf,sqinf)', dvinf, sqinf)
                                if not nombre % sqinf \
                                   and sqinf % 6 in(1, 5):
                                    print('E if(compare): sqinf =', sqinf)
                                    compare(sqinf)
                                if ipsup > 1:
                                    sqinf = int(dvinf ** .5)
                                    print('E sqinf', sqinf)
                                    for e in range(2, sqinf):
                                        if not dvinf % e:
                                            typ = 1
                                            if e % 6 in (1, 5) \
                                                    and e not in horscourse:
                                                print('E for(compare): e =', e)
                                                compare(e)
                                                break
                                    else:
                                        typ = 0
                            print('  E sqinf', sqinf)
                            print('  E else dvinf', dvinf)
                            for hoip in horscourse[1:]:
                                if not dvinf % hoip:
                                    hodv = dvinf // hoip
                                    ho6 = hodv % 6
                                    if ho6 in (1, 5) \
                                       and hodv not in horscourse:
                                        print(
                                            '  E for(compare): hodv =',
                                            hodv)
                                        compare(hodv)
                                        break
                                if hoip > sqinf:
                                    break
        wu[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers
    Composition des hors course"""
    wu = [0]  # Indice d'écriture des lecteurs(1&5)
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    if horscourse:
        # Traitement basique
        for h in horscourse:
            for o in horscourse:
                oh = h * o
                if not nombre % oh and oh not in horscourse:
                    if oh > carre and not nombre % (nombre // oh):
                        if (nombre // oh) not in horscourse:
                            print('Basic compare: n>carre =', oh)
                            compare(nombre // oh)
                            break
                    elif oh <= carre:
                        print('Basic compare: n<carre =', oh)
                        compare(oh)
                        break
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers
    Condition évolutive des lecteurs"""
    while p1[0] <= cartyp6[0]:
        while wu[0] < 1:  # Effet de boucle visu
            print('    while P1', p1,'Q1', q1)
            print('    while cartyp6', cartyp6,'borne', borne)
            print('W')
            break
        if hautmulti_[0] == 0:
            print('    W break hautmulti_', hautmulti_)
            break
        elif p1[0] > d1[0]:
            print('    W break p1>d1', p1[0], d1[0])
            break
        elif len(hautniveau) < 3 and p1[0] > int(borne[0]**.9163):
            print('    W break p1>borne', p1[0], int(borne[0]**.9163))
            break
        # Lectures
        if p1[0] == 0:  # Révision nombre
            print('    W P1', p1[0])
            print('    W n%P1', nombre % p1[0])
        if not nombre % p1[0] and p1[0] not in hautniveau \
                and p1[0] not in horscourse:
            print('  W p1', p1[0])
            compare(p1[0])
        if not nombre % p5[0] and p5[0] not in hautniveau \
                and p5[0] not in horscourse:
            print('  W p5', p5[0])
            compare(p5[0])
        if not nombre % q1[0] and q1[0] not in hautniveau \
                and q1[0] not in horscourse:
            print('  W q1', q1[0])
            compare(q1[0])
        if not nombre % q5[0] and q5[0] not in hautniveau \
                and q5[0] not in horscourse:
            print('  W q5', q5[0])
            compare(q5[0])
        if not nombre % m1[0] and m1[0] not in hautniveau \
                and m1[0] not in horscourse:
            print('  W m1', m1[0])
            compare(m1[0])
        if not nombre % m5[0] and m5[0] not in hautniveau \
                and m5[0] not in horscourse:
            print('  W m5', m5[0])
            compare(m5[0])
        if not nombre % d1[0] and d1[0] not in hautniveau \
                and d1[0] not in horscourse:
            print('  W d1', d1[0])
            compare(d1[0])
        if not nombre % d5[0] and d5[0] not in hautniveau \
                and d5[0] not in horscourse:
            print('  W d5', d5[0])
            compare(d5[0])
        p1[0] += 6
        p5[0] += 6
        q1[0] -= 6
        q5[0] -= 6
        m1[0] += 6
        m5[0] += 6
        d1[0] -= 6
        d5[0] -= 6
        wu[0] += 1
    if nombre != 0:
        """Désigne la communauté:
        Les nombres premiers associés :hautniveau:
        Produisent la communauté des multiples communs"""
        hi = [u for u in horscourse if u <= carre]
        hi = len(hi)
        hautniveau.sort()
        print('carre %s cartyp6 %s borne %s' % (carre, cartyp6, borne))
        print('Premiers (', hi, ')ex\n', hautniveau)
        for i in horscourse[:hi]:
            if breakComm == 0:
                iii = -1
                while horscourse[iii] >= carre:
                    iii -= 1
                    pass
                else:
                    ha = horscourse[iii]
                hu = horscourse[0]
                print('Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} Types {}&{}'
                      .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
                print('  {} * {} Types {}&{}'
                      .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
                break
            else:
                print('{} * {} Types {}&{}'
                      .format(i, nombre // i, i % 6, (nombre // i) % 6))
        print('nphullmen_8x.py En: \n', time.time() - time_)
        print('', )
    Ces débuts enchevêtrent plusieurs traitements, ils demandent à être résumés selon des motifs bien précis. Puis en gardant ce qui est "vraiment" nécessaire, il y a des chances de trouver les nombres communs sans utiliser les itérations. Ce qui manque à ce tableau ce sont les éléments de couplages supérieurs à la racine carrée, quotients de contenant inférieur du tableau hors course. Ainsi en croisant les inférieurs avec les supérieurs, on augmente d'un traitement par rapport à l'existant.

    C'est à dire que ce n'est pas terminé, même si l'existant démontre le contraire du point de vue algorithmique
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  16. #56
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut

    Citation Envoyé par toumic Voir le message
    Bonjour
    Quand on ne me connaît pas, on se demande toujours : Mais qu'est-ce qu'il raconte ?

    Heureusement pour nous, nous n'avons pas besoin de nous comprendre entièrement, et pour le cas qui me concerne ce sera partiellement. Tout définir est un travail de longue haleine, et puisque je passe mon temps à coder ce simple petit programme qui m'accapare. Jusqu'à aujourd'hui, et encore une fois, j'exclame mon plaisir commun à chacun d'entre nous, puisse profiter de ce code si tel n'est pas le cas

    Comme dit, les nombres forment un rassemblement invraisemblable. Ils sont difficiles à cerner, et toutes ces avancées amènent à des bonnes compréhensions.
    Bonne continuation à tous ceux qui cheminent parmi l'univers des nombres...

    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
    379
    380
    381
    382
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Objet : Apprendre par la pratique
    # MusicAtoumic nphullmen_8x Ce 14 décembre 2017
    """Pyhton Compulsion Commune"""
    import time
    time_ = time.time()
     
    def zero(z):
        if z == 1:
            z = 0
            print('Premiers (', z, ')ex\n', '[0]')
            print('{} * {} Types {}&{}'
                  .format(z, z, z % 6, z % 6))
            print('nphullmen_6x.py En: \n', time.time() - time_)
        else:
            print('nphullmen_6x.py En: \n', time.time() - time_)
     
    # 999888777666555000111222333444555 1304562926286024619985807821
    # 1234567898765432112345678987654321
    # 999888777666555666777888999 987898765456543212321
    # 999888777666555444333222111 222557130146747222557130146747
    # _____________________ 111222333222111000111222333222111
    # :nombre: objet unique
    nombre = 222557130146747222557130146747
    print('Nombre =', nombre, '; typ =', nombre % 6)
    # :breakComm: printage communs
    breakComm = 0
    # :zero: instruction zéro
    if nombre == 0:
        zero(breakComm)
    elif nombre < 0:
        nombre = abs(nombre)
    # :carre: service axial
    carre = int(nombre ** .5)
    hautniveau = []  # Liste premiers
    horscourse = []  # Liste communs ip&dv
    hautmulti_ = [1]  # Mul.hautniveau
    horsmulti_ = [1]  # Mul.horscourse
    c12tableau = []  # Liste communs dv
    # Lecteurs initiaux
    p1 = [7]
    p5 = [11]
    m1 = [0]
    m5 = [0]
    d1 = [0]
    d5 = [0]
    q1 = [0]
    q5 = [0]
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
    borne = int(cartyp6[0] ** .992)
    borne = [borne]
    print('cartyp6 = %s ; borne = %s' % (cartyp6, borne))
     
    def forme15(rng_, r6_,mng_, m6_):
        """Positionnement des Lecteurs (bas/hauts)
            P1: Point (+6) Type (1)
                Position inférieure :ip: Inf.carre
            Q1: Point (-6) Type (5)
                Position supérieure :dv: Sup.carre"""
        if r6_ == 1:
            q1[0] = rng_
        else:
            dfo_ = r6_ - 1
            q1[0] = rng_ - dfo_
     
        if m6_ == 1:
            m1[0] = mng_
            d1[0] = mng_
        else:
            dfo_ = m6_ - 1
            m1[0] = mng_ - dfo_
            d1[0] = mng_ - dfo_
     
     
        # Position P5
        p5[0] = p1[0] - 2
        # Position Q5
        q5[0] = q1[0] - 2
        # Position M5
        m5[0] = m1[0] - 2
        d5[0] = d1[0] - 2
        print(' f15 p1, typ', p1[0], p1[0] % 6)
        print(' f15 d1, typ', d1[0], d1[0] % 6)
     
    if nombre != 0:
        mib0 = borne[0] // 2
        forme15(borne[0], borne[0] % 6, mib0, mib0 % 6)
     
    def compare(c):
        """Réception et traitement (c)"""
        hautmulti_[0] = 1
        didi = [c]
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
                horscourse.sort()
            sqc = int(c ** .5)
            for dd in range(2, sqc):
                if not c % dd:
                    didi.append(dd)
                    dddv = c // dd
                    didi.append(dddv)
                    didi.sort()
                    break            
            # Priorité :didi:
            print('C didi', didi)
            for di in didi:
                c = di
                for haut in hautniveau[1:]:
                    if not c % haut:
                        break
                else:
                    hautniveau.append(c)
            # Production haut niveau
            for hha in hautniveau:
                hautmulti_[0] *= hha
            if hautmulti_[0] != 0:
                print('Oniveau =', sorted(hautniveau))
                print('Omulti_ =', hautmulti_)
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        # Séparation :carre:
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    print('C max: c12 =', max(c12tableau))
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        # :ctab: Occurence :c12:
                        if iptab not in horscourse:
                            for hh in hautniveau[1:]:
                                if not iptab % hh:
                                    break
                            else:
                                print('C c12 compare: iptab =', iptab)
                                compare(iptab)
                    if hautmulti_[0]:
                        c12ip = nombre // max(hautniveau)
                        # :c12ip: Sup.carre(dv) de Max.premier(ip)
                        print('C c12ip, max(c12)', c12ip, max(c12tableau))
                        if max(c12tableau) > c12ip:
                            hautmulti_[0] = 0
                            print('C BREAK max(c12)', max(c12tableau))
                if hautmulti_[0]:
                    horsmulti_[0] = 1
                    # Production hors course
                    for hho in horscourse:
                        if horsmulti_[0] <= nombre:
                            horsmulti_[0] *= hho
                    print('C coms(', len(horscourse), ')ex HORS(',
                          max(horscourse), ')')
                    print('C  ****HORSmulti_', horsmulti_)
                    cartyp6[0] = int((nombre // max(hautniveau)) ** .499)
                    brn = int(cartyp6[0] ** .5)
                    borne[0] = brn
                    print('C cartyp6 =', cartyp6, 'borne =', borne)
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        print('Cm if hautmulti', hautmulti_[0])
                        hdv = hautmulti_[0] * hautniveau[1]
                        # :hdv: Son.carre(dv) par Min.hautniveau
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            # :hip: Son(ip) du Son.carre(dv)
                            if hip not in horscourse:
                                print('Cm compare: hip =', hip)
                                compare(hip)
                print('C')
                if hautmulti_[0]:
                    # Termes racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                        print('E BREAK multi_==', nombre)
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                        print('E BREAK multi*min(c)', hautmulti_)
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                        print('E BREAK multi*min(n)', hautmulti_)
                    elif (nombre // hautmulti_[0]) <= max(hautniveau):
                        hautmulti_[0] = 0
                        print('E BREAK n/multi <= max(haut)', hautmulti_)
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                        print('E BREAK hors(nombre)', nombre)
                    else:
                        # Différentiel comparatif
                        dvinf = nombre // max(horscourse)
                        ipsup = dvinf // max(horscourse)
                        sqinf = int(dvinf ** .5)
                        print('E (,sqinf)', sqinf)
                        print('E nombre//max(hors) dvinf =', dvinf)
                        print('E dvinf//max(hors) ipsup =', ipsup)
                        if len(hautniveau) > 2:
                            typ = 0
                            if ipsup >= carre:
                                if borne[0] == int(carre ** .992):
                                    bord = int(borne[0] ** .7)
                                else:
                                    bord = int(carre ** .5)
                                rng = bord
                                r6 = rng % 6
                                print('E rng', rng,
                                      'dv*.5', int(dvinf ** .499))
                                mib1 = borne[0] // 2
                                forme15(rng, r6, mib1, mib1 % 6)
                            else:
                                print('E else(dvinf,sqinf)', dvinf, sqinf)
                                if not nombre % sqinf \
                                   and sqinf % 6 in(1, 5):
                                    print('E if(compare): sqinf =', sqinf)
                                    compare(sqinf)
                                if ipsup > 1:
                                    sqinf = int(dvinf ** .5)
                                    print('E sqinf', sqinf)
                                    for e in range(2, sqinf):
                                        if not dvinf % e:
                                            typ = 1
                                            if e % 6 in (1, 5) \
                                                    and e not in horscourse:
                                                print('E for(compare): e =', e)
                                                compare(e)
                                                break
                                    else:
                                        typ = 0
                            print('  E sqinf', sqinf)
                            print('  E else dvinf', dvinf)
                            for hoip in horscourse[1:]:
                                if not dvinf % hoip:
                                    hodv = dvinf // hoip
                                    ho6 = hodv % 6
                                    if ho6 in (1, 5) \
                                       and hodv not in horscourse:
                                        print(
                                            '  E for(compare): hodv =',
                                            hodv)
                                        compare(hodv)
                                        break
                                if hoip > sqinf:
                                    break
        wu[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers
    Composition des hors course"""
    wu = [0]  # Indice d'écriture des lecteurs(1&5)
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    if horscourse:
        # Traitement basique
        for h in horscourse:
            for o in horscourse:
                oh = h * o
                if not nombre % oh and oh not in horscourse:
                    if oh > carre and not nombre % (nombre // oh):
                        if (nombre // oh) not in horscourse:
                            print('Basic compare: n>carre =', oh)
                            compare(nombre // oh)
                            break
                    elif oh <= carre:
                        print('Basic compare: n<carre =', oh)
                        compare(oh)
                        break
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers
    Condition évolutive des lecteurs"""
    while p1[0] <= cartyp6[0]:
        while wu[0] < 1:  # Effet de boucle visu
            print('    while P1', p1,'Q1', q1)
            print('    while cartyp6', cartyp6,'borne', borne)
            print('W')
            break
        if hautmulti_[0] == 0:
            print('    W break hautmulti_', hautmulti_)
            break
        elif p1[0] > d1[0]:
            print('    W break p1>d1', p1[0], d1[0])
            break
        elif len(hautniveau) < 3 and p1[0] > int(borne[0]**.9163):
            print('    W break p1>borne', p1[0], int(borne[0]**.9163))
            break
        # Lectures
        if p1[0] == 0:  # Révision nombre
            print('    W P1', p1[0])
            print('    W n%P1', nombre % p1[0])
        if not nombre % p1[0] and p1[0] not in hautniveau \
                and p1[0] not in horscourse:
            print('  W p1', p1[0])
            compare(p1[0])
        if not nombre % p5[0] and p5[0] not in hautniveau \
                and p5[0] not in horscourse:
            print('  W p5', p5[0])
            compare(p5[0])
        if not nombre % q1[0] and q1[0] not in hautniveau \
                and q1[0] not in horscourse:
            print('  W q1', q1[0])
            compare(q1[0])
        if not nombre % q5[0] and q5[0] not in hautniveau \
                and q5[0] not in horscourse:
            print('  W q5', q5[0])
            compare(q5[0])
        if not nombre % m1[0] and m1[0] not in hautniveau \
                and m1[0] not in horscourse:
            print('  W m1', m1[0])
            compare(m1[0])
        if not nombre % m5[0] and m5[0] not in hautniveau \
                and m5[0] not in horscourse:
            print('  W m5', m5[0])
            compare(m5[0])
        if not nombre % d1[0] and d1[0] not in hautniveau \
                and d1[0] not in horscourse:
            print('  W d1', d1[0])
            compare(d1[0])
        if not nombre % d5[0] and d5[0] not in hautniveau \
                and d5[0] not in horscourse:
            print('  W d5', d5[0])
            compare(d5[0])
        p1[0] += 6
        p5[0] += 6
        q1[0] -= 6
        q5[0] -= 6
        m1[0] += 6
        m5[0] += 6
        d1[0] -= 6
        d5[0] -= 6
        wu[0] += 1
    if nombre != 0:
        """Désigne la communauté:
        Les nombres premiers associés :hautniveau:
        Produisent la communauté des multiples communs"""
        hi = [u for u in horscourse if u <= carre]
        hi = len(hi)
        hautniveau.sort()
        print('carre %s cartyp6 %s borne %s' % (carre, cartyp6, borne))
        print('Premiers (', hi, ')ex\n', hautniveau)
        for i in horscourse[:hi]:
            if breakComm == 0:
                iii = -1
                while horscourse[iii] >= carre:
                    iii -= 1
                    pass
                else:
                    ha = horscourse[iii]
                hu = horscourse[0]
                print('Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} Types {}&{}'
                      .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
                print('  {} * {} Types {}&{}'
                      .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
                break
            else:
                print('{} * {} Types {}&{}'
                      .format(i, nombre // i, i % 6, (nombre // i) % 6))
        print('nphullmen_8x.py En: \n', time.time() - time_)
        print('', )
    Ces débuts enchevêtrent plusieurs traitements, ils demandent à être résumés selon des motifs bien précis. Puis en gardant ce qui est "vraiment" nécessaire, il y a des chances de trouver les nombres communs sans utiliser les itérations. Ce qui manque à ce tableau ce sont les éléments de couplages supérieurs à la racine carrée, quotients de contenant inférieur du tableau hors course. Ainsi en croisant les inférieurs avec les supérieurs, on augmente d'un traitement par rapport à l'existant.

    C'est à dire que ce n'est pas terminé, même si l'existant démontre le contraire du point de vue algorithmique
    ...
    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
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Objet : Apprendre par la pratique
    # MusicAtoumic nphullmen_8x Ce 16 décembre 2017
    """Pyhton Compulsion Commune"""
    import time
    time_ = time.time()
     
    def wifi():
        print('nphullmen_8x.py En: \n', time.time() - time_)
     
    def zero(z):
        if z == 1:
            z = 0
            print('Premiers (', z, ')ex\n', '[0]')
            print('{} * {} Types {}&{}'
                  .format(z, z, z % 6, z % 6))
            wifi()
        else:
            wifi()
     
    # 913746825159575396321478 865157831052031219 break p1>d1
    # 999888777666555000111222333444555 1304562926286024619985807821 break p1>d1
    # 1234567898765432112345678987654321 35922330097087379 break O
    # 999888777666555666777888999 107407407407411 break O
    # 987898765456543212321 149186400093469 break p1>d1
    # 999888777666555444333222111 3720779432467990087981 break p1>d1
    # 222557130146747222557130146747 476012969567993 break O
    # 111222333222111000111222333222111 11210988789011211 break O
    """Affiner le code en limitant les itérations inutiles
    En ajustant les différentes bornes de lecture
    Chaque nombre a sa propre finalité, ici il y a deux fins
    Break 0 ; Quand la condition finale est logique. Sans problème !
    Break p1>d1 ; Quand se finit la lecture ajustée. Erreur source ?
    """
    # _____________________
    # :nombre: objet unique
    nombre = 111222333222111000111222333222111
    print('Nombre =', nombre, '; typ =', nombre % 6)
    # :breakComm: printage communs
    breakComm = 0
    # :zero: instruction zéro
    if nombre == 0:
        zero(breakComm)
    elif nombre < 0:
        nombre = abs(nombre)
    # :carre: service axial
    carre = int(nombre ** .5)
    hautniveau = []  # Liste premiers
    horscourse = []  # Liste communs ip&dv
    hautmulti_ = [1]  # Mul.hautniveau
    horsmulti_ = [1]  # Mul.horscourse
    c12tableau = []  # Liste communs dv
    # Lecteurs initiaux
    p1 = [7]  # Intro +6 type 1
    p5 = [11]
    d1 = [0]  # Mi carre -6 type 1
    d5 = [0]
    m1 = [0]  # Mi carre +6 type 1
    m5 = [0]
    q1 = [0]  # Carre -6 type 1
    q5 = [0]
    p0 = [0]  # Portion vide
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    cartyp6 = [carre]
    borne = int(cartyp6[0] ** .992)
    borne = [borne]
    print('cartyp6 = %s ; borne = %s' % (cartyp6, borne))
     
    def forme15(rng_, r6_, mng_, m6_):
        """Positionnement des Lecteurs (bas/hauts)
            P1: Point (+6) Type (1)
                Position inférieure :ip: Inf.carre
            Q1: Point (-6) Type (5)
                Position supérieure :dv: Sup.carre"""
        if r6_ == 1:
            q1[0] = rng_
        else:
            dfo_ = r6_ - 1
            q1[0] = rng_ - dfo_
        if m6_ == 1:
            m1[0] = mng_
            d1[0] = mng_
        else:
            dfo_ = m6_ - 1
            m1[0] = mng_ - dfo_
            d1[0] = mng_ - dfo_
        # Position P5
        p5[0] = p1[0] - 2
        # Position Q5
        q5[0] = q1[0] - 2
        # Position M5
        m5[0] = m1[0] - 2
        d5[0] = d1[0] - 2
        print(' f15 p1, d1, q1', p1[0], d1[0], q1[0])
     
    if nombre != 0:
        mib0 = borne[0] // 2
        forme15(borne[0], borne[0] % 6, mib0, mib0 % 6)
     
    def compare(c):
        """Réception et traitement (c)"""
        hautmulti_[0] = 1
        didi = [c]
        if c not in horscourse:
            if c > 1:
                horscourse.append(c)
                horscourse.sort()
            sqc = int(c ** .4)
            for dd in range(2, sqc):
                if not c % dd:
                    dddv = c // dd
                    if dd not in horscourse \
                            and dd % 6 in (1, 5):
                        didi.append(dd)
                    if dddv not in horscourse \
                            and dddv % 6 in (1, 5):
                        didi.append(dddv)
                    sqd = int(dddv ** .4)
                    for vv in range(2, sqd):
                        if not dddv % vv:
                            vvd = dddv // vv
                            if vv not in horscourse \
                                    and vv % 6 in (1, 5):
                                didi.append(vv)
                            if vvd not in horscourse \
                                    and vvd % 6 in (1, 5):
                                didi.append(vvd)
                                break
                    didi.sort()
                    break
                    # Priorité :didi:
            print('C didi', didi)
            for di in didi:
                c = di
                for haut in hautniveau[1:]:
                    if not c % haut:
                        break
                else:
                    hautniveau.append(c)
            # Production haut niveau
            for hha in hautniveau:
                hautmulti_[0] *= hha
            if hautmulti_[0] != 0:
                print('  Oniveau =', sorted(hautniveau))
                print('  Omulti_ =', hautmulti_)
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        # Séparation :carre:
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    print('C max: c12 =', max(c12tableau))
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        # :ctab: Occurence :c12:
                        if iptab not in horscourse:
                            for hh in hautniveau[1:]:
                                if not iptab % hh:
                                    break
                            else:
                                print('C c12 compare: iptab =', iptab)
                                compare(iptab)
                    if hautmulti_[0]:
                        c12ip = nombre // max(hautniveau)
                        # :c12ip: Sup.carre(dv) de Max.premier(ip)
                        # print('C c12ip, max(c12)', c12ip, max(c12tableau))
                        if max(c12tableau) > c12ip:
                            hautmulti_[0] = 0
                            print('C BREAK max(c12)', max(c12tableau))
                if hautmulti_[0]:
                    horsmulti_[0] = 1
                    # Production hors course
                    for hho in horscourse:
                        if horsmulti_[0] <= nombre:
                            horsmulti_[0] *= hho
                    print('C coms(', len(horscourse), ')ex HORS(',
                          max(horscourse), ')')
                    print('C  ****HORSmulti_', horsmulti_)
                    cartyp6[0] = int((nombre // max(hautniveau)) ** .499)
                    brn = int(cartyp6[0] ** .5)
                    borne[0] = brn
                    print('C cartyp6 =', cartyp6, 'borne =', borne)
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        # print('Cm if hautmulti', hautmulti_[0])
                        hdv = hautmulti_[0] * hautniveau[1]
                        # :hdv: Son.carre(dv) par Min.hautniveau
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            # :hip: Son(ip) du Son.carre(dv)
                            if hip not in horscourse:
                                print('Cm compare: hip =', hip)
                                compare(hip)
                print('C')
                if hautmulti_[0]:
                    # Termes racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                        print('E BREAK multi_==', nombre)
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                        print('E BREAK multi*min(c)', hautmulti_)
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                        print('E BREAK multi*min(n)', hautmulti_)
                    elif (nombre // hautmulti_[0]) <= max(hautniveau):
                        hautmulti_[0] = 0
                        print('E BREAK n/multi <= max(haut)', hautmulti_)
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                        print('E BREAK hors(nombre)', nombre)
                    else:
                        # Différentiel comparatif
                        dvinf = nombre // max(horscourse)
                        ipsup = dvinf // max(horscourse)
                        sqinf = int(dvinf ** .5)
                        # print('E (,sqinf)', sqinf)
                        # print('E nombre//max(hors) dvinf =', dvinf)
                        print('E dvinf//max(hors) ipsup =', ipsup)
                        if len(hautniveau) > 2:
                            if ipsup >= carre:
                                if borne[0] == int(carre ** .992):
                                    bord = int(
                                        (nombre // max(hautniveau)) ** .3)
                                    print(' E if bord', bord)
                                else:
                                    bord = int(
                                        (nombre // max(hautniveau)) ** .2)
                                    print(' E else bord', bord)
                                rng = bord
                                r6 = rng % 6
                                mib1 = (rng - max(hautniveau)) // 2
                                print('E if f15', mib1, rng)
                                forme15(rng, r6, mib1, mib1 % 6)
                            else:
                                if not nombre % sqinf \
                                        and sqinf % 6 in (1, 5):
                                    print(
                                        'E if(compare): sqinf =',
                                        sqinf)
                                    compare(sqinf)
                                if ipsup > max(hautniveau):
                                    sqinf = int(ipsup ** .6)  # Cadre ajusté
                                    rng = sqinf
                                    r6 = rng % 6
                                    mib1 = (rng - max(hautniveau)) // 2
                                    print('E else f15', mib1, rng)
                                    forme15(rng, r6, mib1, mib1 % 6)
                            for hoip in horscourse[1:]:
                                if not dvinf % hoip:
                                    hodv = dvinf // hoip
                                    ho6 = hodv % 6
                                    if ho6 in (1, 5) \
                                            and hodv not in horscourse:
                                        print(
                                            'E (compare): hodv =', hodv)
                                        compare(hodv)
                                        break
                                elif hoip > sqinf:
                                    break
        wu[0] = 0
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers
    Composition des hors course"""
    wu = [0]  # Indice d'écriture des lecteurs(1&5)
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    if horscourse:
        # Traitement basique
        for h in horscourse:
            for o in horscourse:
                oh = h * o
                if not nombre % oh and oh not in horscourse:
                    if oh > carre and not nombre % (nombre // oh):
                        if (nombre // oh) not in horscourse:
                            print('Basic compare: n>carre =', oh)
                            compare(nombre // oh)
                            break
                    elif oh <= carre:
                        print('Basic compare: n<carre =', oh)
                        compare(oh)
                        break
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers
    Condition évolutive des lecteurs"""
    while p1[0] <= cartyp6[0]:
        while wu[0] < 1:  # Effet de boucle visu
            print('    while P1', p1, 'D1', d1, 'Q1', q1)
            print('    while cartyp6', cartyp6, 'borne', borne)
            print('W')
            break
        if hautmulti_[0] == 0:
            print('    W break hautmulti_', hautmulti_)
            break
        elif p1[0] > d1[0]:
            print('    W break p1>d1', p1[0], d1[0])
            break
        elif len(hautniveau) < 3 and p1[0] > int(borne[0] ** .4):
            print('    W break p1>borne', p1[0], int(borne[0] ** .4))
            break
        # Lectures
        if p1[0] == 0:  # Révision nombre
            print('    W P1', p1[0], int(borne[0] ** .916))
            print('    W n%P1', nombre % p1[0])
        if not nombre % p1[0] and p1[0] not in hautniveau \
                and p1[0] not in horscourse:
            print('  W____P1', p1[0])
            compare(p1[0])
        if not nombre % p5[0] and p5[0] not in hautniveau \
                and p5[0] not in horscourse:
            print('  W____P5', p5[0])
            compare(p5[0])
        if not nombre % q1[0] and q1[0] not in hautniveau \
                and q1[0] not in horscourse:
            print('  W____Q1', q1[0])
            compare(q1[0])
        if not nombre % q5[0] and q5[0] not in hautniveau \
                and q5[0] not in horscourse:
            print('  W____Q5', q5[0])
            compare(q5[0])
        if not nombre % m1[0] and m1[0] not in hautniveau \
                and m1[0] not in horscourse:
            print('  W____M1', m1[0])
            compare(m1[0])
        if not nombre % m5[0] and m5[0] not in hautniveau \
                and m5[0] not in horscourse:
            print('  W____M5', m5[0])
            compare(m5[0])
        if not nombre % d1[0] and d1[0] not in hautniveau \
                and d1[0] not in horscourse:
            print('  W____D1', d1[0])
            compare(d1[0])
        if not nombre % d5[0] and d5[0] not in hautniveau \
                and d5[0] not in horscourse:
            print('  W____D5', d5[0])
            compare(d5[0])
        p1[0] += 6
        p5[0] += 6
        q1[0] -= 6
        q5[0] -= 6
        m1[0] += 6
        m5[0] += 6
        d1[0] -= 6
        d5[0] -= 6
        wu[0] += 1
    if nombre != 0:
        """Désigne la communauté:
        Les nombres premiers associés :hautniveau:
        Produisent la communauté des multiples communs"""
        hi = [u for u in horscourse if u <= carre]
        hi = len(hi)
        hautniveau.sort()
        print('carre %s cartyp6 %s borne %s' % (carre, cartyp6, borne))
        print('Premiers (', hi, ')ex\n', hautniveau)
        for i in horscourse[:hi]:
            if breakComm == 0:
                iii = -1
                while horscourse[iii] >= carre:
                    iii -= 1
                    pass
                else:
                    ha = horscourse[iii]
                hu = horscourse[0]
                print('Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} Types {}&{}'
                      .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
                print('  {} * {} Types {}&{}'
                      .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
                break
            else:
                print('{} * {} Types {}&{}'
                      .format(i, nombre // i, i % 6, (nombre // i) % 6))
        wifi()
    #
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  17. #57
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut C'est noël, c'est cadeau

    L'incroyable symbolique des nombres et associés communs, afin de cerner le problème il a fallut développer le contexte qui donne sa résolution.
    Toutes les conditions ne sont pas réunies pour répondre à une nécessité de fin de boucle, notamment celle qui n'a plus besoin d'être itérée.

    Ce qui manquait ici, était de saisir les définitions des arguments. Ils ont une orientation par leurs propres faits, ils nous repèrent en plein milieu du développement. Leurs indications déterminent si le développement des communs est terminé ou pas, ça signifie que parmi les communs il y a un nombre premier situé en partie supérieure de la racine carrée.

    Meilleure continuité avec Python Qui fait son caméléon Léon


    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # MusicAtoumic logcompare.py Ce 28 décembre 2017
    """ RUN unique, pour un problème commun"""
    print('MusicAtoumic content')
    # Comment exploiter les tranches communes ?
    """ Pour ce nombre :nbr:, qui développe des communs
    En partant de la petite communauté (chiffre seul)
    En croisant un diviseur commun d'ordre premier
        Premier à multiplier en tant que commun
        Première production et limite commune
            :dvinftable: Les Limites Communes
    :oniveau: Les Communs Premiers
        Cet ensemble est une production conditionnée
        En réponse en terme de multiple commun :nbr:
        Chaque élément :oniveau: a son :dvinftable:
            :oniveau[1]: Premier commun
                :oniveau[1] = 3
            :dvinftable[0]: Première limite
                :dvinftable[0] = 37032917691353905345674893
    """  # Commencer une histoire communautaire 
    # Cet assemblage est une tenue de route
    nbr = 999888777666555444333222111
    ipsuptable = [27, 999, 268731]
    dvinftable = [37032917691353905345674893,
                  1000889667333889333666889,
                  3720779432467990087981]
    dvinf = [3720779432467990087981]
    oniveau = [1, 3, 37, 269]
    ipsup = [] # Descendance...
    # Le couple (ip&dv) multiplié, est commun si (:ip*dv = nbr:)
    """ :nbr: Losqu'il a des tranches communes
    :dvinftable: A des limites développées
        Si la limite de poids fort n'est pas d'ordre premier
        C'est qu'un couple commun produit sa reproduction
        Et, s'il elle est une limite n'ayant pas de diviseur
            Lorsqu'une série de diviseurs communs
            Forme une quantité de quotients (et multiples)
            Ici, (:oniveau:) produit:
                :nbr // dvinftable[2] = 268731:
                :oniveau = 3*37*269 = 268731:
                :oniveau * dvinftable[2] = nbr:
                Cette résolution est vraie:
                    Tant que (:min(dvinftable):) EST PREMIER
        Chaque limite est ou n'est pas une Limite Première
    :oniveau: A un élément ajouté:
        :dvinf[0]: Limite (:dvinftable[-1]:)
        Parvenir à cerner l'indivisible à l'aide du divisible
        Les points forts et faibles ont ce commun ajouté
        Toujours situé à proximité de la racine carrée (:nbr**.5:)
        Comme on peut le voir ci-dessous, au cas par cas
        À l'image d'un éventail circulant entre (:nbr&dvinf[0]:)
    """  # Répartition des communautés
    print('**************')
    print(' nbr = ', nbr, '\n oniveau:', oniveau)
    i = 0
    for ipon in oniveau[1:]:  # Les Communs Premiers
        for dvon in dvinftable:  # Les Limites Communes
            nid = dvon // ipon  # Multiple inverse
            roue = dvon
            dvas = []  # Groupe commun
            if dvon % ipon:  # Hors commun
                while 1:
                    roue *= ipon  # Ascenseur commun
                    if not nbr % roue and roue < nbr:
                        dvas.append(roue)
                    else:  # Tour final
                        break
                print('dvas:', dvas)
            elif not nbr % nid:  # Bonne première
                # print('nid:', nid, 'dvon:', dvon)
                pass
        print(i, 'Oo°  ipon, dvon  *', ipon, dvinftable[i])
        print('')
        if i < len(dvinftable) - 1:
            i += 1
    print('**************')
    print('ipsuptable:', ipsuptable)
    for dvin in dvinftable:  # Cas (:dvin < nbr:) par cas
        cas = dvin // dvinf[0]  # :cas: Couple Racine (:nbr**.5:)
        print(' Couple CAS:', cas, 'DV:', dvin)
        f = 1
        for ipsu in ipsuptable:  # :ipsu: Tranches (max(communs))
            but = ipsu * cas  # :but: Produit (Couple * Tranche)
            if not nbr % (ipsu * cas):
                print('  Tranche BUT:', but, 'IP:', ipsu, 'n°', f)
                f += 1
    print('**************')
    """
    :cas: Unité ("IP") couplée au Quotient Premier ("DV")
    :dvin: "ip.DV(fort)" Unité de couple ("DV")
    :dvinf[0]: Nombre Premier connu ("DV") de poids faibe
        Ce nombre (:dvinf[0]:) est inconnu au début...
    :cas = dvin // dvinf[0]: Et, "IP.dv(fort)"
        Le cas (:dvin:) est un élément de couple lié au
        Quotient Premier (":dvinf[0]:"). Atteignant aussi
        un niveau tranché pas encore développé, voire inconnu.
        En ascension vers les communs inconnus jusqu'ici
    :but: Unité ("IP") assimilée en mode Quotient Premier
    :ipsu: "IP.dv(fort)" Commun de poids fort
    :cas: Unité ("IP") du Quotient Premier (":dvinf[0]:")
    :but = ipsu * cas: Ainsi qu'("IP.dv(fort)")
        Le cas (:but:) a un but, celui d'associer une tranche
        aux nombres multiples. La série des (":ipsu:") unie
        le plus fort multiple(27) issu du Nombre Premier(3),
        avec le cas (:cas:) comme argument couplé.
            ("ipsuptable: [27, 999, 268731]")
            Composé d'unités de poids forts
                ("oniveau: [1, 3, 37, 269]")
                Composé d'unités de poids faibles
    """  # Propagation méthodique du couple
    """:ipsuptable: Composition des maximums
    :for dvin in dvinftable: Cas inférieurs à (:nbr:)
        Aux éléments "DV" couples diviseurs (:nbr:)
        Comme premiers quotients démultipliés (:cas:)
        :cas: Est le quotient (:dvin // dvinf[0]:)
            Et l'élément de couple commun à (:nbr:)
            Ce cas a une valeur "IP" utile
    :for ipsu in ipsuptable: Premières tranches communes
        Aux éléments "IP" en couple "DV" d'(:dvinftable:)
        Comme une référence d'intervalle commun
        :but: Est (:ipsu(IP) * cas(IP):)
            :ipsu: Commun fort du premier commun
            ***Nombre Premier == Commun Premier
    """  # Nombres Premiers multiples (:nbr:)
    """
    Le premier nombre multiple (:nbr:) Produit des communs
    Il forme une communauté de nombres d'éléments de poids ("IP")
    Cette première tranche occupe une quantité de diviseurs, à la
    limite du niveau de seuil hors du commun. L'élément ("IP") de
    poids fort ayant peu de communs, apporte tant de réponses. Ici,
    le cas ("DV") a des arguments:
        IP.dv(faible) = 3 | ip.DV(faible) = 333296259222185148111074037
        IP.dv(fort) = 27 | ip.DV(fort) = 37032917691353905345674893
        ip.DV(fort): Premier échelon de poids fort, dans (:dvinftable:)
    Ici, le Nombre Premier ("DV") est connu pour sa démultiplication.
    Il démultiplie les communs spécifiquement relevés, trouvant leurs
    racines le Nombre Premier ("DV"), proche d'(:ip.DV(fort)**.5:).
    """  # Mise en condition thématique
    """
    *:dvinftable[0]: Tranche n° 1
    Premiers ( 4 )ex [1, 37, 269]
    1 * 37032917691353905345674893 Types 1&5
    37 * 1000889667333889333666889 Types 1&5
    269 * 137668839001315633255297 Types 5&1
    9953 * 3720779432467990087981 Types 5&1
    nphullmen_7x.py En: 0.37087273597717285
    *:dvinftable[1]: Tranche n° 2
    Premiers ( 2 )ex [1, 269]
    1 * 1000889667333889333666889 Types 1&5
    269 * 3720779432467990087981 Types 5&1
    nphullmen_7x.py En: 0.24109673500061035
    *Comparaison Cosmic
    Premiers ( 16 )ex [1, 3, 37, 269]
    1 * 999888777666555444333222111 Types 1&3
    3 * 333296259222185148111074037 Types 3&3
    9 * 111098753074061716037024679 Types 3&3
    27 * 37032917691353905345674893 Types 3&5
    37 * 27024021018015012009006003 Types 1&3
    111 * 9008007006005004003002001 Types 3&3
    269 * 3717058653035522097893019 Types 5&3
    333 * 3002669002001668001000667 Types 3&3
    807 * 1239019551011840699297673 Types 3&3
    999 * 1000889667333889333666889 Types 3&5
    2421 * 413006517003946899765891 Types 3&3
    7263 * 137668839001315633255297 Types 3&1
    9953 * 100461044676635732375487 Types 5&3
    29859 * 33487014892211910791829 Types 3&3
    89577 * 11162338297403970263943 Types 3&3
    268731 * 3720779432467990087981 Types 3&1
    nphullmen_7x.py En: 0.6955530643463135
    """  # Cas par cas des tranches composées
    print('RUN unique, pour un problème commun')
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  18. #58
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut

    Citation Envoyé par VinsS Voir le message
    J'avais toujours soupçonné que toumic est un robot, maintenant j'en ai la preuve.
    Libre comme un robot ? On ne peut le dire
    Libre comme un homme, on peut
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  19. #59
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Structures du nombre

    N bon conseil Commencer par 1
    Du nombre expliqué par des nombres, et de son uniformité commune.
    Élémentairement engagé dans les divisions organisées autour du nombre original, puis un premier élément lorsque le diviseur de la division a un quotient sans reste. Ce qui de l’obtenu est un multiple couplé au quotient, ce diviseur de poids faible associé à un quotient de poids fort.
    Nombre = diviseur * quotient | = 1 * Nombre
    Nombre = ip * dv | = Couple (ip, dv)
    Au début le champ de recherche se limitait à la racine carré du nombre, il représentait le côté symétrique du nombre. Une valeur décimale hors du commun, et un champ réductif supporté. La symétrie (racine²) se fait sur le plus petit élément de poids fort, dans ce développement par cycle.
    Nombre1 = diviseur1 * quotient1 | Champ1 = quotient1 **.5
    Nombre1 = diviseur 2* quotient2 | Champ2 = quotient2 **.5
    Nombre1 = diviseur 3* quotient3 | Champ3 = quotient3 **.5
    L’harmonie du nombre a une expression divisant l’unité en parts égales, où le nombre se réparti en 1.
    Harmonie1 = 1 / Nombre | Unité originale
    Harmonie1 = (1 / ip) * (1 / dv) | Unité unitaire
    Harmonie2 = ip / dv | Unité du couple
    Le couple aux deux éléments de masse opposée, il applique la règle de la division. Pour que le dividende soit de poids fort, et le diviseur de poids faible. D’une inversion harmonique à une version enharmonique, il y a un espace allant au-delà du champ racine².
    Couple = dividende / diviseur | = Couple = dv / ip
    L’enharmonie du nombre évolue en harmonie avec les communs, en augmentant la généralité exprimée par les multiples. Tandis que le champ se limite à la racine², l’augmentation est limitée au nombre qui de poids fort passe à poids faible.

    Pour une mise en forme originale
    Origine forme
    Reportage sur les communs
    Mise en évidence des valeurs communes
    Diviseur * Quotient:::::::::::::::::::::::::::::::ip*dv
    Couple de communs inséparables,
    aux multiples à charges opposées.
    L'élément faible augmente sa charge,,,,,,,,,,,ip
    l'élément fort diminue sa charge..............dv
    Couplage orienté:
    Selon le poids fort du nombre
    Selon le poids faible du un 1
    D'un à racine carrée du nombre............ip(sup)
    Du côté poids fort de la racine...........dv(inf)
    Nombre = Nombre dividende entier
    Quotients entiers:
    Quand le reste de la division vaut zéro,
    diviseur et quotient forme un couple.
    Ou nombre premier
    carre = Racine carrée du Nombre racine²
    Symétrie du nombre:
    Localisation par les nombres variables,
    en voisinage à la racine² de poids fort.
    Le premier couple, est; 1 * nombre,,,,,,,,ip(sup)*dv(inf)
    Le 2ème; diviseur * quotient..............ip(sup)*dv(inf)
    Ce 2ème couple est voisin à la racine².
    Orbite racine²:
    Racine² du poids fort quotient (dv))))dv(inf)
    Division rapport au couple::::::::::::dv(inf)//ip(sup)
    Cette mise à l'échelle déportée,
    situe un nombre conditionnel......raprap
    Les journeaux communs:
    Mots clés = [Nombre,racine²,premier]
    Le nombre développe des premiers communs
    Le couple symétrise un axe racine²
    Résumé périodique des premiers multiples
    *** Périodique
    Oniveau = Les premiers communs
    C Orscourse = Les premiers produits
    E ipsuptable = Les max(Orscourse)
    T dvinftable = Le Nombre//ipsuptable
    .T sqrdvs = int(rapdvs ** .5)
    Symétrie Quotient racine²
    Change la valeur racine²
    .T rapnbr = Rapport: Nombre//(dv//ip)
    Rapport du nombre reporté,
    trilogie 'rapnbr,nombre,raprap'.
    ..T rapips = ipsuptable(ip)
    ..T rapdvs = dvinftable(dv)
    ..T raprap = rapdvs//rapips
    rapinf = raprap < carre; else rapsup
    Report inverse local
    Triangulaire 'ip,dv,raprap'.
    ..T rapcar = raprap//carre (selon)
    .._T rapcartime[0] Racine suite(T)
    Pour un code plus discret
    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
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Objet : Valeures communes
    # Contexte:
    #   D'un entier initial diviseur entier, et
    #   formé par le produit du couple diviseur.
    # Filtres cycles:
    #   Suppression filtre W borne[0]
    #   Filtre ..T loop sqr
    # Légende:
    #   |ip = élément couple(bas)|
    #   |dv = élément couple(haut)|
    def valeurs():
        print('Original ..T loop sqr')
        print('Valeur 987898765456543212321')
        print('Valeur 1234567898765432112345678987654321')
        print('Valeur 222557130146747222557130146747')
        print('Valeur 111222333222111000111222333222111')
        print('Valeur 999888777666555444333222111')
        print('Valeur 999888777666555000111222333444555')
        print('Valeur ')
     
    def val987_321():
        print('Valeur 987898765456543212321')
        print(""" Reportage sur les communs
        Nombre = 987898765456543212321
        carre = 31430856899
                *** Périodique 1/3
        Oniveau = [1, 3, 7]
        .T sqrdvs = 2592373384
        .T rapnbr = 21609
        ..T rapips = 147
        ..T rapdvs = 6720399765010498043
        ..T raprap = 45717005204153047
        ..T rapcar = 1454526
        ..T loop 94 839818197
        W____P5 107
                *** Périodique 2/3
        Oniveau = [1, 3, 7, 107]
        .T sqrdvs = 250614194
        .T rapnbr = 247401441
        ..T rapips = 15729
        ..T rapdvs = 62807474439350449
        ..T raprap = 3993100288597
        ..T rapcar = 127
        ..T loop sqr 15830
        W____P1 421
                *** Périodique 3/3
        Oniveau = [1, 3, 7, 107, 421]
        .T sqrdvs = 12214188
        .T rapnbr = 43849679323309
        ..T rapips = 6621909
        ..T rapdvs = 149186400093469
        ..T raprap = 22529213
        ..T rapcar = 1395
        .._T else rapcartime[0] 9879508
        W____Q1 9692929
        C c12 compare: iptab = 15391261
        E BREAK n/multi <= max(haut) [0]
        """)
    def val123_321():
        print('Valeur 1234567898765432112345678987654321')
        print(""" Reportage sur les communs
        Nombre = 1234567898765432112345678987654321
        carre = 35136418411178908
                *** Périodique 1/6
        Oniveau = [1, 3]
        .T sqrdvs = 3904046490130990
        .T rapnbr = 6561
        ..T rapips = 81
        ..T rapdvs = 15241578997104100152415789971041
        ..T rapsup = 188167641939556792005133209519
        ..T rapcar = 5355344979603
        ..T loop 94 603609688081987
        W____P5 11
                *** Périodique 2/6
        Oniveau = [1, 3, 11]
        .T sqrdvs = 1177114306533493
        .T rapnbr = 793881
        ..T rapips = 891
        ..T rapdvs = 1385598090645827286583253633731
        ..T rapsup = 1555104478839312330620935615
        ..T rapcar = 44259049418
        ..T loop 94 193702875990975
        W____P1 37
                *** Périodique 3/6
        Oniveau = [1, 3, 11, 37]
        .T sqrdvs = 31813900176580
        .T rapnbr = 1487860808841
        ..T rapips = 1219779
        ..T rapdvs = 1012124244445454555575787899
        ..T rapsup = 829760345476889301730
        ..T rapcar = 23615
        ..T loop sqr 126348516
        W____P1 103
                *** Périodique 4/6
        Oniveau = [1, 3, 11, 37, 103]
        .T sqrdvs = 3134716729658
        .T rapnbr = 15784715320994169
        ..T rapips = 125637237
        ..T rapdvs = 9826448975198587918211533
        ..T rapsup = 78212870720792657
        ..T rapcar = 2
        .._T loop rapnbr 9930214766
        W____P5 4013
                *** Périodique 5/6
        Oniveau = [1, 3, 11, 37, 103, 4013]
        .T sqrdvs = 49483877353
        .T rapnbr = 254199723196242038984523
        ..T rapips = 504182232081
        ..T rapdvs = 2448654117916418619041
        ..T rapinf = 4856684670
        ..T rapcar = 7234650
        .._T else rapcartime[0] 35928219342
        W____P1 333667
                *** Périodique 6/6
        Oniveau = [1, 3, 11, 37, 103, 4013, 333667]
        .T sqrdvs = 189531870
        .T rapnbr = 1234567898765432112345678987654321
        ..T rapips = 34367700965632299
        ..T rapdvs = 35922330097087379
        ..T rapinf = 1
        ..T rapcar = 35136418411178908
        .._T loop sqrdvs 189531870
        E (compare): hodv = 3265666372462489
        E BREAK n/multi <= max(haut) [0]
        """)
    def val222_747():
        print('Valeur 222557130146747222557130146747')
        print(""" Reportage sur les communs
        Nombre = 222557130146747222557130146747
        carre = 471759610550487
                *** Périodique 1/7
        Oniveau = [1, 7]
        .T sqrdvs = 178308372588753
        .T rapnbr = 49
        ..T rapips = 7
        ..T rapdvs = 31793875735249603222447163821
        ..T rapsup = 4541982247892800460349594831 
        ..T rapcar = 9627747154091
        ..T loop 94 32367622919549
        W____P1 13
                *** Périodique 2/7
        Oniveau = [1, 7, 13]
        .T sqrdvs = 49453844631791
        .T rapnbr = 8281
        ..T rapips = 91
        ..T rapdvs = 2445682748865354094034397217
        ..T rapsup = 26875634602915979055323046
        ..T rapcar = 56968918071
        ..T loop 94 9596252283613
        W____P5 11
                *** Périodique 3/7
        Oniveau = [1, 7, 11, 13]
        .T sqrdvs = 4495804057435
        .T rapnbr = 121242121
        ..T rapips = 11011
        ..T rapdvs = 20212254122854166066399977
        ..T rapsup = 1835642005526670244882
        ..T rapcar = 3891053
        ..T loop 94 988237640352
        W____P5 101
                *** Périodique 4/7
        Oniveau = [1, 7, 11, 13, 101]
        .T sqrdvs = 447349223704
        .T rapnbr = 1236790876321
        ..T rapips = 1112111
        ..T rapdvs = 200121327949051149172277
        ..T rapsup = 179947260614319208
        ..T rapcar = 381
        ..T loop sqr 9781107
        W____P1 211
                *** Périodique 5/7
        Oniveau = [1, 7, 11, 13, 101, 211]
        .T sqrdvs = 30796790621
        .T rapnbr = 55063166604700768
        ..T rapips = 234655421
        ..T rapdvs = 948442312554744782807
        ..T rapinf = 4041851275000
        ..T rapcar = 116
        .._T loop rapnbr 245925955
        W____P1 241
                *** Périodique 6/7
        Oniveau = [1, 7, 11, 13, 101, 211, 241]
        .T sqrdvs = 1983795675
        .T rapnbr = 3198123781700050065553
        ..T rapips = 56551956461
        ..T rapdvs = 3935445280310144327
        ..T rapinf = 69589905
        ..T rapcar = 6779138
        .._T else rapcartime[0] 1501860097
        W____P1 2161
                *** Périodique 7/7
        Oniveau = [1, 7, 11, 13, 101, 211, 241, 2161]
        .T sqrdvs = 42674609
        .T rapnbr = 15896937867624801611223581910
        ..T rapips = 122208777912221
        ..T rapdvs = 1821122295377207
        ..T rapinf = 14
        ..T rapcar = 33697115039320
        .._T loop sqrdvs 42674609
        W____P1 6571
        C c12 compare: iptab = 277145380517
        E BREAK n/multi <= max(haut) [0]
        """)
    def val111_111():
        print('Valeur 111222333222111000111222333222111')
        print(""" Reportage sur les communs
        Nombre = 111222333222111000111222333222111
        carre = 10546199942259344
                *** Périodique 1/4
        Oniveau = [1, 3]
        .T sqrdvs = 2029617125197016
        .T rapnbr = 729
        ..T rapips = 27
        ..T rapdvs = 4119345674893000004119345674893
        ..T rapsup = 152568358329370370522938728699
        ..T rapcar = 14466666587461
        ..T loop 94 324659850613680
        Basic borne[0] 2029617125197016
        W____P1 37
                *** Périodique 2/4
        Oniveau = [1, 3, 37]
        .T sqrdvs = 333667000000000
        .T rapnbr = 998001
        ..T rapips = 999
        ..T rapdvs = 111333666889000000111333666889
        ..T rapsup = 111445112001001001112446113
        ..T rapcar = 10567324022
        ..T loop 94 58627444912289
        W____P5 101
                *** Périodique 3/4
        Oniveau = [1, 3, 37, 101]
        .T sqrdvs = 33201107414579
        .T rapnbr = 10180608201
        ..T rapips = 100899
        ..T rapdvs = 1102313533554455446646867989
        ..T raprap = ..T rapsup = 10924920302029310960929
        ..T rapcar = 1035910
        ..T loop sqr 129625827
        W____P1 9901
                *** Périodique 4/4
        Oniveau = [1, 3, 37, 101, 9901]
        .T sqrdvs = 333666833166
        .T rapnbr = 998002996003000992
        ..T rapips = 999000999
        ..T rapdvs = 111333555555444444666889
        ..T rapinf = 111444889111111
        ..T rapcar = 94
        .._T loop rapnbr 1654437752
        W____P1 333667
        C c12 compare: iptab = 999999000001
        E BREAK n/multi <= max(haut) [0]
        """)
    def val999_111():
        print('Valeur 999888777666555444333222111')
        print(""" Reportage sur les communs
        Nombre = 999888777666555444333222111
        carre = 31621017973280
                *** Périodique 1/3
        Oniveau = [1, 3]
        .T sqrdvs = 6085467746307
        .T rapnbr = 729
        ..T rapips = 27
        ..T rapdvs = 37032917691353905345674893
        ..T rapsup = 1371589544124218716506477
        ..T rapcar = 43375881993
        ..T loop 94 1316772290163
        W____P1 37
                *** Périodique 2/3
        Oniveau = [1, 3, 37]
        .T sqrdvs = 1000444734772
        .T rapnbr = 998001
        ..T rapips = 999
        ..T rapdvs = 1000889667333889333666889
        ..T rapsup = 1001891558892782115782
        ..T rapcar = 31684354
        ..T loop 94 237784237125
        W____P5 269
                *** Périodique 3/3
        Oniveau = [1, 3, 37, 269]
        .T sqrdvs = 60998192042
        .T rapnbr = 72216350361
        ..T rapips = 268731
        ..T rapdvs = 3720779432467990087981
        ..T rapsup = 13845739540536782
        ..T rapcar = 437
        ..T loop sqr 246978
        W break om1>q1
        """)
    def val999_555():
        print('Valeur 999888777666555000111222333444555')
        print(""" Reportage sur les communs
        Nombre = 999888777666555000111222333444555
        carre = 31621017973280920
                *** Périodique 1/3
        Oniveau = [1, 3, 5]
        .T sqrdvs = 8164511733376161
        .T rapnbr = 225
        ..T rapips = 15
        ..T rapdvs = 66659251844437000007414822229637
        ..T rapsup = 4443950122962466667160988148642
        ..T rapcar = 140537857659026
        ..T loop 94 1214814162065715
        Basic borne[0] 8164511733376161
        W____P1 37
                *** Périodique 2/3
        Oniveau = [1, 3, 5, 37]
        .T sqrdvs = 1342237460809748
        .T rapnbr = 308025
        ..T rapips = 555
        ..T rapdvs = 1801601401201000000200400600801
        ..T rapsup = 3246128650812612612973694776
        ..T rapcar = 102657310196
        ..T loop 94 219372522443266
        W____P1 1381
                *** Périodique 3/3
        Oniveau = [1, 3, 5, 37, 1381]
        .T sqrdvs = 36118733730379
        .T rapnbr = 587453267025
        ..T rapips = 766455
        ..T rapdvs = 1304562926286024619985807821
        ..T rapsup = 1702073737252708404258
        ..T rapcar = 53827
        ..T loop sqr 136345092
        W break om1>q1
        """)
     
    def val000_000():
        print('Valeur ')
        print(""" Reportage sur les communs
        Nombre =
        carre = 
                *** Périodique 
        Oniveau = 
        .T sqrdvs = 
        .T rapnbr = 
        ..T rapips = 
        ..T rapdvs = 
        ..T raprap = 
        ..T rapcar = 
        .._T rapcartime[0] 
        """)
    # Suivi ..T loop sqr:
    """
    n 987898765456543212321 ***
                *** Périodique 2/3
        Oniveau = [1, 3, 7, 107]
        .T sqrdvs = 250614194
        .T rapnbr = 247401441
        ..T rapips = 15729
        ..T rapdvs = 62807474439350449
        ..T raprap = 3993100288597
        ..T rapcar = 127
        ..T loop sqr 15830
        W____P1 421
    """
    """
    n 1234567898765432112345678987654321
                *** Périodique 3/6
        Oniveau = [1, 3, 11, 37]
        .T sqrdvs = 31813900176580
        .T rapnbr = 1487860808841
        ..T rapips = 1219779
        ..T rapdvs = 1012124244445454555575787899
        ..T rapsup = 829760345476889301730
        ..T rapcar = 23615
        ..T loop sqr 126348516
        W____P1 103
    """
    """
    n 222557130146747222557130146747
                *** Périodique 4/7
        Oniveau = [1, 7, 11, 13, 101]
        .T sqrdvs = 447349223704
        .T rapnbr = 1236790876321
        ..T rapips = 1112111
        ..T rapdvs = 200121327949051149172277
        ..T rapsup = 179947260614319208
        ..T rapcar = 381
        ..T loop sqr 9781107
        W____P1 211
    """
    """
    n 111222333222111000111222333222111
                *** Périodique 3/4
        Oniveau = [1, 3, 37, 101]
        .T sqrdvs = 33201107414579
        .T rapnbr = 10180608201
        ..T rapips = 100899
        ..T rapdvs = 1102313533554455446646867989
        ..T raprap = ..T rapsup = 10924920302029310960929
        ..T rapcar = 1035910
        ..T loop sqr 129625827
        W____P1 9901
    """
    """
    n 999888777666555444333222111
                *** Périodique 3/3
        Oniveau = [1, 3, 37, 269]
        .T sqrdvs = 60998192042
        .T rapnbr = 72216350361
        ..T rapips = 268731
        ..T rapdvs = 3720779432467990087981
        ..T rapsup = 13845739540536782
        ..T rapcar = 437
        ..T loop sqr 246978
        W break om1>q1
    """
    """
    n 999888777666555000111222333444555
                *** Périodique 3/3
        Oniveau = [1, 3, 5, 37, 1381]
        .T sqrdvs = 36118733730379
        .T rapnbr = 587453267025
        ..T rapips = 766455
        ..T rapdvs = 1304562926286024619985807821
        ..T rapsup = 1702073737252708404258
        ..T rapcar = 53827
        ..T loop sqr 136345092
        W break om1>q1
    """
    def origine():
        print('Origine forme')
        print(""" Reportage sur les communs
        Mise en évidence des valeurs communes
    Diviseur * Quotient:::::::::::::::::::::::::::::::ip*dv
        Couple de communs inséparables,
        aux multiples à charges opposées.
        L'élément faible augmente sa charge,,,,,,,,,,,ip
        l'élément fort diminue sa charge..............dv
        Couplage orienté:
            Selon le poids fort du nombre
            Selon le poids faible du un               1
            D'un à racine carrée du nombre............ip(sup)
            Du côté poids fort de la racine...........dv(inf)
    Nombre = Nombre dividende entier
        Quotients entiers:
            Quand le reste de la division vaut zéro,
            diviseur et quotient forme un couple.
        Ou nombre premier
    carre = Racine carrée du Nombre                   racine²
        Symétrie du nombre:
            Localisation par les nombres variables,
            en voisinage à la racine² de poids fort.
            Le premier couple, est; 1 * nombre,,,,,,,,ip(sup)*dv(inf)
            Le 2ème; diviseur * quotient..............ip(sup)*dv(inf)
            Ce 2ème couple est voisin à la racine².
            Orbite racine²:
                Racine² du poids fort quotient (dv))))dv(inf)
                Division rapport au couple::::::::::::dv(inf)//ip(sup)
                    Cette mise à l'échelle déportée,
                    situe un nombre conditionnel......raprap
    Les journeaux communs:
        Mots clés = [Nombre,racine²,premier]
        Le nombre développe des premiers communs
        Le couple symétrise un axe racine²
        Résumé périodique des premiers multiples
            *** Périodique
    Oniveau = Les premiers communs
    C Orscourse = Les premiers produits
    E ipsuptable = Les max(Orscourse)
    T dvinftable = Le Nombre//ipsuptable
    .T sqrdvs = int(rapdvs ** .5)
            Symétrie Quotient racine²
            Change la valeur racine²
    .T rapnbr = Rapport: Nombre//(dv//ip)
            Rapport du nombre reporté,
            trilogie 'rapnbr,nombre,raprap'.
    ..T rapips = ipsuptable(ip)
    ..T rapdvs = dvinftable(dv)
    ..T raprap = rapdvs//rapips
        rapinf = raprap < carre; else rapsup
            Report inverse local
            Triangulaire 'ip,dv,raprap'.
    ..T rapcar = raprap//carre (selon)
    .._T rapcartime[0] Racine suite(T)
        """)
        print('')
    # valeurs()
    origine()
    # val000_000()
    # val987_321()
    # val123_321()
    # val222_747()
    # val111_111()
    # val999_111()
    # val999_555()
    Afin de comprendre ce numéglyphe par des moyens familiers, il vous faudra chercher la version xa du programme.
    Si plus évolutivement le moyen sans les prints vous correspond
    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
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # Objet : Outil pratique
    # MusicAtoumic nphullmen_12a Ce lundi 19 février 2018
    """Pyhton Compulsion Commune
    Programme évoluant sur une table de travail
    L'histoire des premiers dividendes aux nombres communs
    Produisant des multiples à structures uniques
    Associant les unités en une ligne composée:
        Structure commune ' Nombre Premier = Premier multiple
        (Un nombre peut composer plusieurs premiers communs)'
    La première finalité est alors, liée à une nouvelle fin
        Un nombre peut avoir plusieurs structures communes
        Les structures se chevauchent ou se suivent
    Ce qui détermine la fin, c'est l'(ip.sup & dv.inf)
        (dv.inf): L'unité terminale proche du carré
    """
    import time
    time_ = time.time()
     
    def wifi():
        print('nphullmen_12a.py En: \n', time.time() - time_)
     
    def zero(z):
        if z == 1:
            z = 0
            print('Premiers (', z, ')ex\n', '[0]')
            print('{} * {} Types {}&{}'
                  .format(z, z, z % 6, z % 6))
            wifi()
        else:
            wifi()
     
    # _____________________
    # :nombre: objet unique
    nombre = 456789215975346
    # :breakComm: printage communs
    breakComm = 1
    # :zero: instruction zéro
    if nombre == 0:
        zero(breakComm)
    elif nombre < 0:
        nombre = abs(nombre)
    # :carre: service axial
    carre = int(nombre ** .5)
    cartyp6 = [carre]
    borne = [0]
    hautniveau = []  # Liste premiers
    horscourse = []  # Liste communs ip&dv
    hautmulti_ = [1]  # Mult.hautniveau
    hautcumul_ = []  # Cum.Mult.hautniveau
    horspluri_ = [0]  # Plus.horscourse
    horsmulti_ = [0]  # Mult.horscourse
    horscumul_ = []  # Cum.Mult.horscourse
    c12tableau = []  # Liste communs dv
    dvinftable = []  # Liste tranches dv
    ipsuptable = []  # Liste tranches ip
    ipsupcumul = [1]  # Mult.ipsuptable
    rapcartime = [0]  # Indice niveau dv
    # Lecteurs initiaux
    p1 = [7]  # Intro +6 type 1
    p5 = [11]
    ed1 = [0]  # Mi inf -6 type 1
    ed5 = [0]
    em1 = [0]  # Mi inf +6 type 1
    em5 = [0]
    d1 = [0]  # Mi carre -6 type 1
    d5 = [0]
    m1 = [0]  # Mi carre +6 type 1
    m5 = [0]
    od1 = [0]  # Mi sup -6 type 1
    od5 = [0]
    om1 = [0]  # Mi sup +6 type 1
    om5 = [0]
    q1 = [0]  # Carre -6 type 1
    q5 = [0]
    p0 = [0]  # Portion vide
     
    def forme15(rng_, r6_, mng_, m6_):
        """Positionnement des Lecteurs (bas/hauts)
            P1: Point (+6) Type (1)
                Position inférieure :ip: Inf.carre
            Q1: Point (-6) Type (5)
                Position supérieure :dv: Sup.carre"""
        # Max = rng_ | Axe = mng_
        dom_ = mng_ // 2  # Coaxe = dom_
        edm_ = mng_ - dom_  # Report inf = edm_
        odm_ = mng_ + dom_  # Report sup = odm_
        e6_ = edm_ % 6  # Type inf e6_
        o6_ = odm_ % 6  # Type sup o6_
        if r6_ == 1:
            q1[0] = rng_
        else:
            dfo_ = r6_ - 1
            q1[0] = rng_ - dfo_
        if m6_ == 1:
            m1[0] = mng_
            d1[0] = mng_
        else:
            dfo_ = m6_ - 1
            m1[0] = mng_ - dfo_
            d1[0] = mng_ - dfo_
        if e6_ == 1:
            ed1[0] = edm_
            em1[0] = edm_
        else:
            dfo_ = e6_ - 1
            ed1[0] = edm_ - dfo_
            em1[0] = edm_ - dfo_
        if o6_ == 1:
            od1[0] = odm_
            om1[0] = odm_
        else:
            dfo_ = o6_ - 1
            od1[0] = odm_ - dfo_
            om1[0] = odm_ - dfo_
        # Position P5 (début)
        p5[0] = p1[0] - 2
        # Position E5 (bas)
        ed5[0] = ed1[0] - 2
        em5[0] = em1[0] - 2
        # Position M5 (milieu)
        m5[0] = m1[0] - 2
        d5[0] = d1[0] - 2
        # Position O5 (haut)
        od5[0] = od1[0] - 2
        om5[0] = om1[0] - 2
        # Position Q5 (fin)
        q5[0] = q1[0] - 2
     
    def compare(c):
        """Réception et traitement (c)"""
        if c < 1:
            return
        hautmulti_[0] = 1
        didi = [c]
        con = 1
        if c not in horscourse:
            if carre >= c > 1:
                horscourse.append(c)
                horscourse.sort()
            sqc = int(c ** .501)
            # Démultiplications
            for dd in range(sqc, max(hautniveau), -1):
                con += 1
                if not c % dd or not c % con:
                    # Identifier (dd&con)
                    if not c % dd:
                        dddv = c // dd
                    else:
                        dddv = c // con
                        dd = con
                    # :dd: Explore
                    if dd not in horscourse \
                            and dd % 6 in (1, 5) \
                            and dd not in didi:
                        didi.append(dd)
                        didi.append(dddv)
                        break
                    # :dddv: Explore
                    if dddv >= carre:
                        sqdd = int(dddv ** .4)
                        noc = 1
                        for fd in range(sqdd, max(hautniveau), -1):
                            noc += 1
                            # Condition de fin (noc&fd)
                            if noc > fd:
                                break
                            elif not c % fd or not c % noc:
                                # Identifier (fd&noc)
                                if not c % fd:
                                    dddv = c // fd
                                else:
                                    dddv = c // noc
                                    fd = noc
                                # :fd: Explore
                                if fd not in horscourse \
                                        and fd % 6 in (1, 5) \
                                        and fd not in didi:
                                    didi.append(fd)
                                    break
                    if dddv not in horscourse \
                            and dddv % 6 in (1, 5) \
                            and dddv <= carre \
                            and dddv not in didi:
                        didi.append(dddv)
                    sqd = int(dddv ** .501)
                    if dddv > carre:
                        sqd = int(sqd ** .6)
                    for vv in range(2, sqd):
                        if not dddv % vv:
                            vvd = dddv // vv
                            if vv not in horscourse \
                                    and vv % 6 in (1, 5) \
                                    and vv not in didi:
                                didi.append(vv)
                                break
                            if vvd not in horscourse \
                                    and vvd % 6 in (1, 5) \
                                    and vvd not in didi:
                                sqv = int(vvd ** .5)
                                ffd = []
                                for q in range(2, sqv):
                                    if not vvd % q and vvd not in didi:
                                        veq = vvd // q
                                        ffd.append(q)
                                        ffd.append(veq)
                                        break
                                if ffd:
                                    for f in ffd:
                                        vvd = f
                                        if vvd not in dvinftable and vvd not in didi:
                                            didi.append(vvd)
                                            break
                                else:
                                    if vvd not in dvinftable:
                                        dvinftable.append(vvd)
                                        didi.append(vvd)
                                        break
                    didi.sort()
                    # Priorité :didi:
                    break
            for di in sorted(didi):
                c = di
                for haut in hautniveau[1:]:
                    if not c % haut:
                        break
                else:
                    if c <= carre:
                        hautniveau.append(c)
                    elif c not in dvinftable:
                        dvinftable.append(c)
            # Production haut niveau
            for hha in hautniveau:
                hautmulti_[0] *= hha
                if hautmulti_[0] not in hautcumul_:
                    hautcumul_.append(hautmulti_[0])
            if hautmulti_[0] != 0:
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        # Séparation :carre:
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        # :ctab: Occurence :c12:
                        if iptab not in horscourse:
                            for hh in hautniveau[1:]:
                                if not iptab % hh:
                                    break
                            else:
                                compare(iptab)
                if hautmulti_[0] > 0:
                    horspluri_[0] = 0
                    horsmulti_[0] = 1
                    # Production hors course
                    for hho in horscourse:
                        if horspluri_[0] <= nombre:
                            horspluri_[0] += hho
                            horsmulti_[0] *= hho
                    horscumul_.append(max(horscourse))
                    cartyp6[0] = int((nombre // max(horscourse)) ** .5)
                    brn = int(cartyp6[0] ** .9478)
                    borne[0] = brn
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        hdv = hautmulti_[0] * hautniveau[1]
                        # :hdv: Son.carre(dv) par Min.hautniveau
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            # :hip: Son(ip) du Son.carre(dv)
                            if hip not in horscourse:
                                compare(hip)
                if hautmulti_[0]:
                    # Termes racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                    elif (nombre // hautmulti_[0]) <= max(hautniveau):
                        hautmulti_[0] = 0
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                    elif max(horscourse) ** 2 > nombre:
                        hautmulti_[0] = 0
                    elif hautmulti_[0]:
                        # Différentiel comparatif
                        dvinf = nombre // max(horscourse)
                        ipsup = dvinf // max(horscourse)
                        sqinf = int(dvinf ** .501)
                        if max(horscourse) not in ipsuptable:
                            ipsuptable.append(max(horscourse))
                            ipsupcumul[0] *= max(horscourse)
                        if dvinf not in dvinftable:
                            dvinftable.append(dvinf)
                            if ipsuptable:
                                rapcartime[0] = 0
                                rapips = max(ipsuptable)
                                rapdvs = min(dvinftable)
                                sqrdvs = int(rapdvs ** .5)
                                rapnbr = nombre // (rapdvs // rapips)
                                if rapnbr > max(ipsuptable):
                                    raprap = rapdvs // rapips
                                    if raprap >= carre:
                                        rapcar = raprap // carre
                                    else:
                                        rapcar = carre // raprap
                                    if rapcar > sqrdvs:
                                        rapcartime[0] = sqrdvs
                                    elif max(hautniveau) > rapcar > 1:
                                        if rapnbr > sqrdvs:
                                            rapcartime[0] = int(sqrdvs ** .8)
                                    elif rapcar < 2:
                                        sqrap = int(raprap ** .5)
                                        if sqrap > max(hautniveau):
                                            rapcartime[0] = sqrap
                                        else:
                                            rapcartime[0] = raprap
                                    else:
                                        if raprap > carre:
                                            if rapcar < int(sqrdvs ** .5):
                                                rapcartime[0] = int(sqrdvs ** .6)
                                            else:
                                                rapcartime[0] = int(sqrdvs ** .948)
                                        else:
                                            rapcartime[0] = int(sqrdvs ** .987)
                                else:
                                    rapcartime[0] = rapnbr
                        if len(hautniveau) > 2:
                            if hautmulti_[0]:
                                if ipsup >= carre:
                                    if rapcartime[0] > 1:
                                        sqinf = rapcartime[0]
                                    else:
                                        sqinf = int(dvinf ** .5)
                                    rng = sqinf
                                    cartyp6[0] = rng
                                    brn = int(cartyp6[0])
                                    borne[0] = brn
                                    r6 = rng % 6
                                    mib1 = (rng - max(hautniveau)) // 2
                                    forme15(rng, r6, mib1, mib1 % 6)
                                else:
                                    if not nombre % sqinf \
                                            and sqinf % 6 in (1, 5):
                                        compare(sqinf)
                                    if ipsup < max(horscourse) and c12tableau:
                                        pass
                                    else:
                                        if rapcartime[0] > 1:
                                            sqinf = rapcartime[0]
                                        else:
                                            sqinf = int(dvinf ** .5)
                                        rng = sqinf
                                        r6 = rng % 6
                                        mib1 = (rng - max(hautniveau)) // 2
                                        if mib1 < p1[0]:
                                            mib1 = p1[0]
                                        forme15(rng, r6, mib1, mib1 % 6)
                                    for hoip in horscourse[1:]:
                                        if not dvinf % hoip:
                                            hodv = dvinf // hoip
                                            ho6 = hodv % 6
                                            if ho6 in (1, 5) \
                                                    and hodv not in horscourse:
                                                compare(hodv)
                                                break
                                        elif hoip > sqinf:
                                            break
     
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers
    Composition des hors course"""
    basniveau = [1, 2, 3, 5]
    for i in range(1, 7):
        if not nombre % i and i <= carre:
            def rang(ti, i_):
                if ti == 1:  # Nombre Premier(basniveau)
                    hautniveau.append(i_)
                    horscourse.append(i_)
                else:  # Nombre Commun(basniveau)
                    horscourse.append(i_)
     
            if i in basniveau:
                rang(1, i)
            else:
                rang(2, i)
    if horscourse:
        # Traitement basique
        for h in horscourse:
            for o in horscourse:
                oh = h * o
                if not nombre % oh and oh not in horscourse:
                    if oh > carre and not nombre % (nombre // oh):
                        if (nombre // oh) not in horscourse:
                            compare(nombre // oh)
                            break
                    elif oh <= carre:
                        compare(oh)
                        break
        dvhors = nombre // max(horscourse)
        borne[0] = int(dvhors ** .5)
    """Borne & cartyp6
    Borne : Limite en pleine forêt
    Cartyp6 : Limite en plein ciel"""
    if not borne:
        borne = cartyp6
    if nombre != 0:
        mib0 = borne[0] // 2
        forme15(borne[0], borne[0] % 6, mib0, mib0 % 6)
    """Hauts niveaux premiers: cartyp6
    Itérer dans l'alignement des nombres premiers
    Condition évolutive des lecteurs"""
    while p1[0] <= cartyp6[0]:
        if hautmulti_[0] == 0:
            break
        elif om1[0] > q1[0]:
            break
        # Lecteurs en lecture
        if not nombre % p1[0] and p1[0] not in hautniveau \
                and p1[0] not in horscourse:
            compare(p1[0])
        if not nombre % p5[0] and p5[0] not in hautniveau \
                and p5[0] not in horscourse:
            compare(p5[0])
        # Lecteurs  
        if not nombre % q1[0] and q1[0] not in hautniveau \
                and q1[0] not in horscourse:
            compare(q1[0])
        if not nombre % q5[0] and q5[0] not in hautniveau \
                and q5[0] not in horscourse:
            compare(q5[0])
        # Lecteurs M: Entre carre (Q) et début (P)
        if not nombre % m1[0] and m1[0] not in hautniveau \
                and m1[0] not in horscourse:
            compare(m1[0])
        if not nombre % m5[0] and m5[0] not in hautniveau \
                and m5[0] not in horscourse:
            compare(m5[0])
        # Lecteurs 
        if not nombre % d1[0] and d1[0] not in hautniveau \
                and d1[0] not in horscourse:
            compare(d1[0])
        if not nombre % d5[0] and d5[0] not in hautniveau \
                and d5[0] not in horscourse:
            compare(d5[0])
        # Lecteurs E: Entre début (P) et mi course (M)
        if not nombre % ed1[0] and ed1[0] not in hautniveau \
                and ed1[0] not in horscourse:
            compare(ed1[0])
        if not nombre % ed5[0] and ed5[0] not in hautniveau \
                and ed5[0] not in horscourse:
            compare(ed5[0])
        if not nombre % em1[0] and em1[0] not in hautniveau \
                and em1[0] not in horscourse:
            compare(em1[0])
        if not nombre % em5[0] and em5[0] not in hautniveau \
                and em5[0] not in horscourse:
            compare(em5[0])
        # Lecteurs O: Entre carre (Q) et mi course (M)
        if not nombre % od1[0] and od1[0] not in hautniveau \
                and od1[0] not in horscourse:
            compare(od1[0])
        if not nombre % od5[0] and od5[0] not in hautniveau \
                and od5[0] not in horscourse:
            compare(od5[0])
        if not nombre % om1[0] and om1[0] not in hautniveau \
                and om1[0] not in horscourse:
            compare(om1[0])
        if not nombre % om5[0] and om5[0] not in hautniveau \
                and om5[0] not in horscourse:
            compare(om5[0])
        p1[0] += 6
        p5[0] += 6
        q1[0] -= 6
        q5[0] -= 6
        m1[0] += 6
        m5[0] += 6
        d1[0] -= 6
        d5[0] -= 6
        # 3ème niveau de profondeur
        ed1[0] -= 6
        ed5[0] -= 6
        em1[0] += 6
        em5[0] += 6
        od1[0] -= 6
        od5[0] -= 6
        om1[0] += 6
        om5[0] += 6
    if nombre != 0:
        """Désigne la communauté:
        Les nombres premiers associés :hautniveau:
        Produisent la communauté des multiples communs"""
        hi = [u for u in horscourse if u <= carre]
        hi = len(hi)
        hautniveau.sort()
        print('Premiers (', hi, ')ex\n', hautniveau, carre)
        for i in horscourse[:hi]:
            if breakComm == 0:
                iii = -1
                while horscourse[iii] >= carre:
                    iii -= 1
                    pass
                else:
                    ha = horscourse[iii]
                hu = horscourse[0]
                print("Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} "
                      "Types {}&{}".format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
                print(
                    '  {} * {} Types {}&{}'.format(
                        ha, nombre // ha, ha % 6, (nombre // ha) % 6))
                break
            else:
                print(
                    '{} * {} Types {}&{}'.format(
                        i, nombre // i, i % 6, (nombre // i) % 6))
        wifi()
    #
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

  20. #60
    Membre éclairé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 61
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 311
    Points : 752
    Points
    752
    Billets dans le blog
    23

    Par défaut Module de l'escalade décimale

    L'itération est linéaire, elle s'incrémente par petit pas. Aussi associer plusieurs itératifs gagne en espace, sans avoir un millier d'itérant à gérer. On peut s'introduire dans les intervalles libres, en se rapportant aux quantités de chiffres qui composent les nombres. Sûrement parce que l'itération est régulière, et son assurance donne le moyen d'y associer une stratégie. Qui a chaque itération vient créer un bouclage décimal, et c'est ce dernier qui est présenté

    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Escalades décimales
    # nphazsix.py
    # _______ tête
    dic = {}
     
    def phases(ph):
        """ La demande :ph: via la fonction :phases:
        :ph: Quantité de chiffres formant la racine²
        :phases: Puissante escalade du six
            Le six élémentaire est l'incrémentation
            en lecture de type 1 en type 1.
            (Le typage a le reste du diviseur six)
        Quand la racine carrée a 30 chiffres
            :phases: Adaptation des types
                3..so:21 i:26 no:[21] po:20
                ..o:12 so:30 i:38 no:[21] po:30
            Pour cette racine² l'escale :3(on):
            Il donne la puissance basse :i:26(i):
                6**26 = 170 581 728 179 578 208 256
            Et, la quantité de chiffres :so:21(sos):
            Quatrième groupe limite haute :o:12(o):
                |:i:38(i):,:so:30(sos):|
                6**38 = 371 319 292 745 659 279 662 190 166 016
        Informe sur les puissances typiques
            Alignés aux types premiers (1&5)
                Critère d'incrémetation en lecture (1&5)
            Quelque soit le type original (2,3,4,0)
                Critère d'incrémetation en lecture (2,3,4,0)
        """
        n0 = [0]  # Chef de groupe
        i = pop = on = n0[0] = 0
        """:n0[0]: Base du groupe"""
        #   pop = n0[0] + 9
        """:pop: Forme le groupe"""
        #   if sos <= pop:
        #
        # Tant que ph non atteint
        six = 6
        while pop < ph:
            # Tranches de 10 chiffres
            d1c = []
            d2c = []
            o = p = q = 0
            on += 1
            while o <= 12:  # ! Inconnu :o<=11: !
                sos = len(str(six ** i))
                if not p:
                    if sos <= pop:
                        q = 1
                        pass
                    elif not q:
                        n0[0] = sos
                        print('{}..so:{} i:{} no:{} po:{}'.
                              format(on, sos, i, n0, pop))
                        d1c.append(i)
                        d2c.append(sos)
                        p = 1
                if sos == n0[0] + 9 and q == 0:
                    pop = n0[0] + 9
                    print('..o:{} so:{} i:{} no:{} po:{}'.
                          format(o, sos, i, n0, pop))
                    d1c.append(i)
                    d2c.append(sos)
                    i += 1
                    break
                i += 1
                o += 1
            dic[on] = [d1c, d2c]
        print('***')
     
    # _______ main
    phases(60)
    # Détails du contexte
    """ contexte:
    Cette application vient en queue du programme principal à
    charge de concevoir l'ensemble des nombres communs. Lui-même
    paramétré selon l'offre du chiffre six en terrain commun, et
    de sa définition itérative. Les renseignements vont enrichir
    chaque point d'itération des lecteurs, à pas de géant.
    """  # Plus Maths
    # Maths au rapport
    """ rapport
    Pour chaque nombre, il y a un type:
        Type = nombre % 6 | Type = reste
    Pour chaque nombre, il y a un commun:
        Commun universel = 1
        Commun quotien = nombre / diviseur = entier
    Les communs sont inégaux:
        Types différents_
            Pour un nombre assemblé de communs, produisant
            une série de types bien définis, variants
            selon leur mutiplicité.
        Préalables premiers_
            Tous les nombres communs sont originaires
            des nombres premiers, et premiers communs.
            Tous ces premiers multiples se départagent
            les deux lignées, celles des types un et cinq.
            En fait, il s'agit de positionner la lecture.
            Qui pourra, alors rencontrer un premier nombre.
    """  # Plus Phases
    # _______ pied
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple ET logcomplixpy

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo