IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Téléchargez Python Discussion :

La racine carrée du nombre


Sujet :

Téléchargez Python

  1. #1
    Robot Forum
    Avatar de forum
    Inscrit en
    novembre 1999
    Messages
    2 443
    Détails du profil
    Informations forums :
    Inscription : novembre 1999
    Messages : 2 443
    Points : 2 494
    Points
    2 494
    Par défaut La racine carrée du nombre
    Bonjour,

    Je vous propose un nouvel élément à utiliser : La racine carrée du nombre

    Ce code présente une racine carrée à l'aide du module decimal



    C'est aussi un moyen de découvrir comment se fait cette opération...

    Qu'en pensez-vous ?

  2. #2
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    décembre 2007
    Messages
    4 263
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : décembre 2007
    Messages : 4 263
    Points : 8 889
    Points
    8 889
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    Selon l'objectif de ce code, voir aussi la méthode de Heron d'Alexandrie qui est très efficace, bien qu'elle ait 2000 ans...: https://fr.wikipedia.org/wiki/M%C3%A..._de_H%C3%A9ron.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  3. #3
    Invité
    Invité(e)
    Par défaut
    Bonjour

    Ce programme recherche la racine carrée du nombre de son côté décimal, à partir de la racine entière il va par dizaines incrémentées trouver leurs points de rupture. Ainsi : Décimale = (0.01) est incrémentée = {(0.02), (0.03), (0.04)...}. Si quand elle parvient à (0.05), et que la racine entière à laquelle est ajouté la partie décimale. Ainsi : racine = 33.05, si racine**2 est supérieure à nombre. C'est que sa part décimale a trouvée son point de rupture.

    Ensuite, puisque ce n'est pas terminé. On ajoute une dizaine supplémentaire, ainsi : (0.041) a une chance de rencontrer sa rupture par incrémentation. Comme on peut le comprendre, c'est la partie décimale qui est en cours du traitement principal. Un travail de grammage sur les nombres, sans apport géométrique.

    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 -*-
    # Nombre au carré << nombre2carrex.py >>
     
    from decimal import *
     
    def nombre_carre(nbr):
        """ Cette fonction produit la racine carrée du nombre, et
        elle commence par définir la partie entière de la racine².
        Qui en général a une virgule  flottante ( point  décimal )
        """
        # Racine² décimale entière
        wh = int(nbr ** Decimal('.5'))
        # Plus de précision peut être désapointant
        getcontext().prec = 100  # max = 100000000
        # Secteur décimal
        decitab = []
        recital = 0
        copieur = [0]
        entiere = wh
        print('entiere =', entiere)
        www = top = i9 = 0
        while (Decimal(image[0]) ** 2) < nbr and top == 0:
            iii = 0
            # print('WWW ', recital[0])
            for i in range(1, 10):
                if i == 1:
                    print('i1', i, '...WFIimage', image[0])
                    print('...WFIrecital', recital)
                if decitab:
                    image[0] = (str(entiere) + '.' + recital + str(i))
                    if iii < 2:
                        print('iii', i, '...FIIimage =', image[0])
                        iii += 1
                else:
                    image[0] = (str(entiere) + '.' + str(i))
                    print(www, 'IEimage =', image[0])
                if Decimal(image[0]) ** 2 > nbr:
                    decitab.append(i - 1)
                    recital = (''.join(str(d) for d in decitab))
                    print('i', i, 'Isuprecital =', recital)
                    image[0] = (str(entiere) + '.' + recital)
                    print(www, 'Isupimage =', image[0])
                    if Decimal(image[0]) ** 2 == nbr:  # 1 Valide
                        rondeur[0] = 'Juste racine²'
                        top = 1
                        break
                    break
                elif i == 9:
                    # i9 = 9**1
                    i9 += 1
                    # 9658754876325698546785421556487982 Valide
                    if i9 > 100:
                        top = 1
                        print('___i', i, '___OK i9', i9)
                    if Decimal(image[0]) ** 2 == nbr:
                        rondeur[0] = 'Juste racine²'
                        top = 1
                        break
                    decitab.append(i)
                    recital = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(str(entiere) + '.' + recital)
                    # image[0] = Decimal(float(image[0]))
                    print(www, 'ELimage =', (image[0]), 'i9', i9)
                    print('i9', i, 'ELrecital =', recital)
                elif Decimal(image[0]) ** 2 == nbr:
                    rondeur[0] = 'Juste racine²'
                    top = 1
                    break
            print('* * * Bimage =', image[0])
            print('* * * * * * * recital[0]', recital)
            www += 1
            # break
        else:
            print('Eimage  =', (image[0]), '______')
            # Contrôle des dizaines
            wer = .1
            while Decimal(image[0]) ** 2 > nbr:
                mer = str(wer)[2:]
                copieur[0] = Decimal(str(entiere) + '.' + recital + mer)
                print('EEE ', copieur[0], 'mer', mer, 'len', len(mer))
                print('.EE ', Decimal(copieur[0]) ** 2, wer)
                print('')
                wer /= 10
                if len(str(wer)) > 5:
                    break
            if not nbr:
                rondeur[0] = 1
            print('REELrecite =', recital, len(str(recital)))
            print('REELnombre =', nbr, '; type =', nbr % 6, len(str(nbr)))
            print('REELracine =', nbr ** .5, len(str(nbr ** .5)))
     
    nombre = 56325468791546857  # 96587548785421556487982
    print('nombre =', nombre)
    image = {0: 0}
    rondeur = {}
    nombre_carre(nombre)
    print('image =', image[0], '\nimageoo2 =', (Decimal(image[0]) ** 2))
    if rondeur:
        print('Rondeur :', rondeur[0])
    else:
        rondeur[0] = 'Valeur intervalle'
        print('Rondeur :', rondeur[0],
              '\n', nombre - (Decimal(image[0]) ** 2))

  4. #4
    Invité
    Invité(e)
    Par défaut La racine carrée du nombre
    Satisfait de ce bout de chemin réalisé avec le nombre, et plus particulièrement sa racine carrée.
    Le mode de lecture basique ne suffisait pas à résoudre le problème de clarté des opérations, alors après maintes et maintes virevoltes au milieu des décimales.
    Décimales écosystématiques, redondance visible lorsqu'elles s'occupent des floats. Le monde décimal a besoin d'une technique de déchiffrage qui me dépasse, heureusement le calcul élémentaire a eu finalement raison.
    Maintenant les choses sont plus claires, et la racine carrée est liée a ce petit programme fort simple. Dont le rendu n'est pas compliqué...

    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Nombre au carré << nombre6carrea.py >>
     
    from decimal import *
     
    def resume():
        print("""Le nombre_carre utilise le module decimal...
        La racine carrée réelle a forme générique
        Pour les opérations et les comparaisons
        Le traité se porte sur le nombre (ex:13.25)
        Les nombres négatifs en string dans le code
        Au vu du capable complexe de nombre_carre...""")
     
    def nombre_carre(nbr):
        """ Cette fonction produit la racine carrée du nombre, et
        elle commence par définir la partie entière de la racine².
        Qui en général a une virgule  flottante ( point  décimal )
        """
        nbr = Decimal(nbr)
        if nbr < -0:
            nbr = Decimal(str(nbr)[1:])
            rondeur[1] = 1
        # Précision.Allusion.Illusion.
        """ Modulation unaire"""
        if len(str(nbr)) < 10:
            precision = (len(str(nbr)) + 1) * 10
            precisive = '(*10)'
        elif 10 <= len(str(nbr)) < 50:
            precision = int(len(str(nbr)) ** 1.75)
            precisive = '(**1.75)'
        elif 50 <= len(str(nbr)) < 100:
            precision = int(len(str(nbr)) ** 1.5)
            precisive = '(**1.5)'
        else:
            precision = int(len(str(nbr)) ** 1.125)
            precisive = '(**1.125)'
        getcontext().prec = precision
        # Maximum(machine locale) = 100000000
        # Racine² décimale entière
        wh = int(nbr ** Decimal(.5))
        wh0 = (nbr ** Decimal(.5))
        nbu = nbr
        # Secteur décimal
        decitab = []
        if rondeur[1] == 1:
            entiere[0] = str('-' + str(wh))
        else:
            entiere[0] = str(wh)
        print('entiere =', entiere[0])
        www = nbrdec = top = 0
        while image[0] ** 2 < nbr and top == 0:
            for i in range(1, 10):
                if decitab:
                    image[0] = Decimal(entiere[0] + '.' + recital[0] + str(i))
                else:
                    image[0] = Decimal(entiere[0] + '.' + str(i))
                    nbrdec += 1  # Nombre de décimales
     
                if image[0] ** 2 > nbr:
                    decitab.append(i - 1)
                    nbrdec += 1  # Nombre de décimales
                    recital[0] = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(entiere[0] + '.' + recital[0])
                    if image[0] ** 2 == nbr:
                        rondeur[0] = 'Juste racine² | nbr |'
                        top = 1
                        break
                    break
                elif i == 9:
                    if image[0] ** 2 == nbr:
                        rondeur[0] = 'Juste racine² | i9 |'
                        top = 1
                        break
                    decitab.append(i)
                    nbrdec += 1  # Nombre de décimales
                    recital[0] = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(entiere[0] + '.' + recital[0])
                elif image[0] ** 2 == nbr:
                    rondeur[0] = 'Juste racine² | elif |'
                    top = 1
                    break
            # print(www, '°°° **2 =', image[0] ** 2)
            www += 1
        else:
            if len(str(rondeur[0])) < 1:
                rondeur[2] = 'Variant racine² | not |'
            nb6 = Decimal('6')
            if rondeur[1] == 1:
                nbr = Decimal('-' + str(nbr))
                wh0 = Decimal('-' + str(wh0))
                nb6 = Decimal('-' + '6')
            sq0 = wh0
            print('Rnombre =', nbr, ';type =', nbr % nb6)
            if sq0 ** 2 == nbu:
                print('_Reelle_juste =', sq0)
            else:
                print('_Rracine =', sq0)
            print(',... (', nbrdec, ') Precision', precision, precisive)
     
    # Nombre à forme décimale
    """ Une décimale au format texte a un meilleur suivi """
    # :nombre = '22135323.12554':
    #  imageoo2 = 22135323.125540000000000000000000000000000000...
    # ...00000000000000000000000000000000000000000000000000000000
    # :nombre = 22135323.12554:
    #  imageoo2 = 22135323.125539999455213546752929687500000000...
    # ...00000000000000000000000000000000000000000000000000000000
    """."""
    nombre = 1  # Permission math [-0 exclu]
    nombre = str(Decimal(nombre))
    image = {0: 0}
    rondeur = {0: '', 1: 0}
    entiere = {0: ''}
    recital = [0]
    nombre_carre(nombre)  # Appel principal
    if recital[0] != 0:
        recital[0] = str(image[0])[len(entiere[0]) + 1:]
    print('Rrecital =', recital[0])
    oo2 = image[0] ** 2
    if rondeur[1] == 1:
        oo2 = Decimal('-' + str(oo2))
    print('Iimageoo1 =', image[0],
          '\nIimageoo2 =', oo2)
    if rondeur[0]:
        print('Rondeur 0:', rondeur[0])
    elif rondeur[2]:
        print('Rondeur 2:', rondeur[2], '\nReste =',
              Decimal(nombre) - ((image[0]) ** 2))
    else:
        rondeur[0] = 'Valeur intervalle'
        print('Rondeur 0:', rondeur[0], '\nReste =',
              Decimal(nombre) - ((image[0]) ** 2))
    print('.*')
    resume()
    #

  5. #5
    Invité
    Invité(e)
    Par défaut
    Je viens de mettre à jour l'en cours, en simplifiant la saisie du nombre. Se faisant en format texte directement.
    La définition du typage (%6) se porte non plus seulement sur le nombre entier, mais également sur sa partie décimale.
    Les nombres 23154. et 23154.0 sont admis et modifiés. Car dans le résultat (23154,23154.,23154.0) sont inégaux.
    :

  6. #6
    Invité
    Invité(e)
    Par défaut Nom d'un de là
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    # Séparation décimale pour typage(%6)
    La séparation décimale est une argumentation qui a un double tranchant lorsqu'il s'agit de relever le type(reste(n%6)) d'un nombre réel, où le point décimal crée la limite entre la partie entière du nombre réel et sa part décimale. La démarche a commencée quand le nombre réel avait pour partie visible décimale, l'image exacte de celle du nombre réel. D'où la poursuite en mode séparé, un type(%6) spécifique à chacune.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    decim6 = 6 # Type 6: Supérieur à *(_TTG_)*
    Ce pourquoi la valeur par défaut qui ne sera jamais atteinte par un typage(%6) sur le nombre.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    # Recherche du point décimal
    La recherche du point décimal facilite un prochain calcul, au sujet de la proportion relative à la partie entière du nombre réel.
    La mesure décimale prend en charge l'opération des typages aux mentions (Entier.Décimal).
    Juste avant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    nombre_carre(nombre) # Appel principal
    Ce qui est à venir, va permettre de calculer aux normes du module decimal (espoir content)

    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
     
    """."""
    nombre = '4'
    # Séparation décimale pour typage(%6)
    # *(_TableTypeGénéral = [0,1,2,3,4,5]_)*
    decim6 = 6  # Type 6: Supérieur à *(_TTG_)*
    # Recherche du point décimal
    for i in nombre:
        if i == '.':
            nentie = len(str(int(float(nombre))))  # Poids.Entier.fort
            break
    else:
        # Nombre.Entier
        nentie = len(str(int(nombre)))  # Poids.Entier.faible
    nmasse = len(nombre)  # Masse.Nombre
    nmedif = nmasse - nentie  # Mesure.Decimale 
    ndecim = nombre[nentie + 1:]  # Masse.Decimale
    """ Nombre réel aux poids(types): Entier.Decimal"""
    # Mesure.Decimale
    if nmedif != 0:
        fnd = 0
        for nd in ndecim:
            fnd += int(nd)  # Addition ndecim(nd)
            if fnd != 0:    # Somme positive
                break       # Nombre.Décimal
        if fnd == 0 or nombre[-1] == '.':
            # Nombre.Entier
            nombre = nombre[:nentie]
        else:
            decim6 = int(nombre[nentie + 1:]) % 6
            # Condition nombre négatif
            if nombre[0] == '-':
                decim6 = int(str('-' + str(decim6)))
    image = {0: 0}
    rondeur = {0: '', 1: 0}
    entiere = {0: ''}
    recital = [0]
    nombre_carre(nombre)  # Appel principal

  7. #7
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    décembre 2007
    Messages
    4 263
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : décembre 2007
    Messages : 4 263
    Points : 8 889
    Points
    8 889
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    Juste un petit complément du calcul de la racine carrée sur la base de l'algorithme de Héron d'Alexandrie que j'évoquais plus haut. Même si cet algorithme a environ 2000 ans, il est très efficace!

    Bien sûr, il s'agit d'une démarche d'étude, puisque le calcul de la racine carrée fait déjà partie du système Python (math, decimal, numpy, gmpy2, etc...).

    L'algorithme de Héron d'Alexandrie est basé sur une simple formule récurrente: https://fr.wikipedia.org/wiki/M%C3%A..._de_H%C3%A9ron.

    Voilà sa traduction en Python (Python 3.5):

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    def rac2(x):
        """retourne la racine carrée réelle de x (nombre réel)
           (Algorithme de Héron d'Alexandrie)
        """
        if not isinstance(x, float): x = float(x) 
        if x<0.0: raise ValueError("Racine carrée d'un nombre négatif")
        rn = float(1<<(int(x).bit_length()>>1)) # calcule une racine approchée
        while True:
            rnp1 = (rn + x/rn)/2
            if rnp1==rn:
                return rn # on a fini
            else:
                rn = rnp1
    Application:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    print(rac2(2.0))
    1.414213562373095
    print(math.sqrt(2.0))
    1.4142135623730951
    Si on veut avoir plus de chiffres significatifs, on peut utiliser le module decimal:

    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
    from decimal import Decimal, getcontext
     
    #############################################################################
    def rac2dec(x):
        """Retourne la racine carrée réelle de x (nombre réel)
           Le résultat est de type Decimal(module decimal) 
           La précision est donnée par le "contexte" du module decimal 
           (Algorithme de Héron d'Alexandrie)
        """
        if not isinstance(x, Decimal): x = Decimal(x)
        if Decimal.is_signed(x): raise ValueError("Racine carrée d'un nombre négatif")
        rn = Decimal(1<<(int(x).bit_length()>>1)) # racine approchée
        d2 = Decimal(2.0)
        while True:
            rnp1 = (rn + x/rn)/d2
            if rnp1==rn:
                return rn # on a fini
            else:
                rn = rnp1
    Application pour avoir 100 chiffres:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    getcontext().prec = 100
    print(rac2dec(2.0))
    1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641572
    print(Decimal.sqrt(Decimal(2.0)))
    1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573
    Mais il y a un calcul intéressant qui n'est pas prévu: celui du calcul de la racine carrée entière d'un nombre entier sans passer par un calcul avec décimales. Et comme le type int de Python peut avoir une longueur quelconque, on n'a pas besoin du module décimal pour ça:

    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
    def rac2ent(x):
        """Retourne la racine carrée entière de x (nombre entier)
           (Algorithme de Héron d'Alexandrie)
        """
        if not isinstance(x, int): x = int(x) 
        if x<0: raise ValueError("Racine carrée d'un nombre négatif")
        rn = 1<<(x.bit_length()>>1) # calcule une racine approchée
        delta = x # participe aux conditions d'arrêt
        while True:
            rnp1 = (rn + x//rn)>>1
            if delta<=1 and rnp1>=rn:
                return rn # on a fini
            else:
                delta = abs(rnp1-rn) # calcule pour la boucle suivante
                rn = rnp1
    Application:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    print(rac2ent(123456789123456789123456789123456789))
    351364183040128307
    Comment peut-on prouver qu'on a la bonne racine? C'est facile! Pour avoir la bonne racine r d'un nombre n, on vérifie:
    r*r<=n et (r+1)*(r+1)>n

    Et en bonus, on peut trouver tous les chiffres significatifs de la racine décimale qu'on veut en multipliant n par 10**x avec x divisible par 2. Par exemple:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    print(rac2ent(2*10**198))
    1414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641572
    On a bien tous les chiffres du calcul avec les décimales (voir plus haut), à part le point décimal, bien sûr:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    print(rac2dec(2.0))
    1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641572
    En plus, cet algorithme de Héron d'Alexandrie peut être étendu au calcul des racines en général (cubiques, etc...)! Si quelqu'un est intéressé, je peux développer.

    [edit]: petit ajout. Comme il s'agit d'une formule récurrente (on calcule la valeur suivante avec la valeur précédente), il faut bien fixer une 1ère valeur au début du calcul. Ici, elle pourrait être rn=1 ou rn=x ou n'importe quelle valeur intermédiaire. Mais sur de gros calculs avec des nombres très grands, on gagne beaucoup de temps de calcul en donnant une valeur proche de la racine! Pour ça, voilà comment je fais: je prends comme valeur approchée un nombre qui aurait moitié moins de bits que le nombre x s'il était exprimé en binaire. Prenons un exemple:
    - j'ai x = 1234567890
    - en binaire, ça fait: 1001001100101100000001011010010 soit 31 bits
    - la moitié de bits en entier, ça fait: 31//2 => 15
    - la racine approchée sera donc: 1 suivi de 14 zéro, soit => 32768
    - et on constate que, avec ce calcul simple et rapide, on trouve une racine approchée correcte puisque 32768 comparé à la vraie racine 35136 donne un écart de 7%.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  8. #8
    Invité
    Invité(e)
    Par défaut
    Pour un nombre x = nombre = '652315487.23265487'
    Pour un appel (dec) ou "
    L'algorithme de Héron d'Alexandrie
    " SANS GUILLEMETS
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    >>> Decimal(dec)**2
    Decimal('652315487.2326549291610717773437499999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999')
    >>> Decimal(_Reelle_juste)**2
    Decimal('652315487.2326548700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')
    Pour un appel (
    _Reelle_juste
    ) ou "
    L'algorithme de Python"
    Ou,
    L'algorithme de Héron d'Alexandrie
    " AVEC GUILLEMETS


  9. #9
    Invité
    Invité(e)
    Par défaut
    En revenant sur le code qui m'intéresse, c'est en essayant plusieurs combinaisons opératoires, que je me suis aperçu d'un manque contextuel "Decimal".
    Puisqu'à ce moment du programme le contexte décimal n'est pas encore évalué par le code, donc en ayant ajouté un contexte.
    Le nombre calculé a pris une autre dimension, ainsi que la suite opérationnelle qui suit, et un nouveau résultat...

    Portion de l'opération sur laquelle était nécessaire un apport contextuel :
    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
    def opera(nop):
        """Fonction opératoire"""
        def addition(i, j):
            return i + j
        def soustraction(i, j):
            return i - j
        def multiplie(i, j):
            return i * j
        def expose(i, j):
            return i ** j
        def division(i, j):
            return i / j
        def diventier(i, j):
            return i // j
        def modulo(i, j):
            return i % j
        signe = {'+': addition, '-': soustraction, '*': multiplie,
                 '**': expose, '/': division, '//': diventier,
                 '%': modulo}
        getcontext().prec = len(nop)*50  # CONTEXTE
        nbr1 = Decimal(nop[0])
        operation = signe[nop[1]]
        nbr2 = Decimal(nop[2])
        opombre[0] = str(operation(nbr1, nbr2))
        if 'E' in opombre[0] or 'e' in opombre[0]:
            op_e = []
            op_o = len(opombre[0])
            for ie in range(op_o - 1, 0, -1):
                if opombre[0][ie] in ("E", '+', '-'):
                    break
                else:
                    op_e.append(opombre[0][ie])
            op_r = list(reversed(op_e))
            op_j = (''.join(str(o0) for o0 in op_r))
            getcontext().prec = int(op_j) + op_o
            opombre[0] = str(operation(nbr1, nbr2))
    Comme étant satisfait de cette favorable issue, je vous propose le code général en Python
    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
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Nombre au carré << nombre10carre.py >>
     
    from decimal import *
     
    def resume():
        print("""Le nombre_carre utilise le module decimal...
        La racine carrée réelle a forme générique
        Pour les opérations et les comparaisons
        Le traité se porte sur le nombre (ex:13.25)
        Les nombres négatifs en string dans le code
        Au vu du capable complexe de nombre_carre...""")
     
    def espec6(ome):
        """ Séparation décimale pour typage(%6)
        # *(_TableTypeGénéral = [0,1,2,3,4,5]_)*
        # Type 6: Supérieur à *(_TTG_)"""
        # Recherche du point décimal
        if '.' in ome:
            nentie = 0  # Poids.Entier.fort
            for me in ome:
                nentie += 1
                if me == '.':
                    break
        else:
            # Nombre.Entier
            nentie = len(str(int(ome)))  # Poids.Entier.faible
        nmasse = len(ome)  # Masse.Nombre
        nmedif = nmasse - nentie  # Mesure.Decimale
        ndecim = ome[nentie:]  # Masse.Decimale
        # Mesure.Decimale
        if nmedif != 0:
            fnd = 0
            for nd in ndecim:
                fnd += int(nd)  # Addition ndecim(nd)
                if fnd != 0:  # Somme positive
                    decim6[0] = int(ndecim) % 6
                    # Condition nombre négatif
                    if ome[0] == '-':
                        decim6[0] = int(str('-' + str(decim6[0])))
                    break
     
    def opera(nop):
        """Fonction opératoire"""
        def addition(i, j):
            return i + j
        def soustraction(i, j):
            return i - j
        def multiplie(i, j):
            return i * j
        def expose(i, j):
            return i ** j
        def division(i, j):
            return i / j
        def diventier(i, j):
            return i // j
        def modulo(i, j):
            return i % j
        signe = {'+': addition, '-': soustraction, '*': multiplie,
                 '**': expose, '/': division, '//': diventier,
                 '%': modulo}
        getcontext().prec = len(nop)*50
        nbr1 = Decimal(nop[0])
        operation = signe[nop[1]]
        nbr2 = Decimal(nop[2])
        opombre[0] = str(operation(nbr1, nbr2))
        if 'E' in opombre[0] or 'e' in opombre[0]:
            op_e = []
            op_o = len(opombre[0])
            for ie in range(op_o - 1, 0, -1):
                if opombre[0][ie] in ("E", '+', '-'):
                    break
                else:
                    op_e.append(opombre[0][ie])
            op_r = list(reversed(op_e))
            op_j = (''.join(str(o0) for o0 in op_r))
            getcontext().prec = int(op_j) + op_o
            opombre[0] = str(operation(nbr1, nbr2))
     
    def nombre_carre(nbr):
        """ Cette fonction produit la racine carrée du nombre, et
        elle commence par définir la partie entière de la racine².
        Qui en général a une virgule  flottante ( point  décimal )
        La polarité du nombre signé, forme une transition (+-)
            Analyse de la surface(Typique = Nombre % 6)
                1 = 7 % 6       :7%6: Pôle positif naturel
                -1 = -7 % -6    :-7%-6: Pôle négatif naturel
                5 = -7 % 6      :-7%6: Transit positif naturel
                -5 = 7 % -6     :7%-6: Transit négatif naturel
        """
        nbr = Decimal(nbr)
        if nbr <= -0:
            nbr = Decimal(str(nbr)[1:])
            rondeur[1] = 1
        # Précision.Allusion.Illusion.
        premax = 100000000
        """ Modulation unaire"""
        if len(str(nbr)) < 10:
            precision = (len(str(nbr)) + 1) * 10
            precisive = '(*10)'
        elif 10 <= len(str(nbr)) < 50:
            precision = int(len(str(nbr)) ** 2)
            precisive = '(**2)'
        elif 50 <= len(str(nbr)) < 100:
            precision = int(len(str(nbr)) ** 1.75)
            precisive = '(**1.75)'
        elif 100 <= (int(len(str(nbr)))) < premax:
            precision = int(len(str(nbr)) ** 1.25)
            precisive = '(**1.25)'
        else:
            return
        getcontext().prec = precision
        # Maximum(machine locale) = 100000000
        # Racine² décimale entière
        wh = int(nbr ** Decimal(.5))
        wh0 = (nbr ** Decimal(.5))
        nbu = nbr
        # Secteur décimal
        decitab = []
        if rondeur[1] == 1:
            entiere[0] = str('-' + str(wh))
        else:
            entiere[0] = str(wh)
        print('entiere =', entiere[0])
        www = nbrdec = nc = top = 0
        while image[0] ** 2 <= nbr and top == 0:
            for img in range(1, 10):
                if decitab:
                    image[0] = Decimal(entiere[0] + '.' + recital[0] + str(img))
                else:
                    if not nc:
                        nbrdec += 1  # Unité décimale
                        nc = 1
                    image[0] = Decimal(entiere[0] + '.' + str(img))
                if image[0] ** 2 > nbr:
                    decitab.append(img - 1)
                    nbrdec += 1  # Nombre de décimales
                    recital[0] = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(entiere[0] + '.' + recital[0])
                    if image[0] ** 2 == nbr:
                        rondeur[0] = 'Juste racine² | nbr |'
                        top = 1
                        break
                    break
                elif img == 9:
                    if image[0] ** 2 == nbr:
                        rondeur[0] = 'Juste racine² | i9 |'
                        top = 1
                        break
                    decitab.append(img)
                    nbrdec += 1  # Nombre de décimales
                    recital[0] = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(entiere[0] + '.' + recital[0])
                elif image[0] ** 2 == nbr:
                    rondeur[0] = 'Juste racine² | elif |'
                    top = 1
                    recital[0] = str(image[0])[len(entiere[0]) + 1:]
                    break
            # print(www, '°°° **2 =', image[0] ** 2)
            www += 1
        else:
            if len(str(rondeur[0])) < 1:
                rondeur[2] = 'Variant racine² | not |'
            nb0 = str(int(nbr) % 6)
            if rondeur[1] == 1:
                nbr = Decimal('-' + str(nbr))
                wh0 = Decimal('-' + str(wh0))
                nb0 = '-' + nb0
            sq0 = wh0
            if decim6[0] < 6:
                print('Rnombre =', nbr, ';typo =', [nb0,
                                                    '.', str(decim6[0])])
            else:
                print('Rnombre =', nbr, ';typo =', [nb0])
            if sq0 ** 2 == nbu:
                print('_Rreelle_juste =', sq0)
            else:
                print('_Rracine =', sq0)
            print('*... (', nbrdec, ') Precision', precision, precisive)
     
    # Nombre à forme décimale
    """ Une décimale au format texte a un meilleur suivi """
    # :nombre = '22135323.12554':
    #  imageoo2 = 22135323.125540000000000000000000000000000000...
    # ...00000000000000000000000000000000000000000000000000000000
    # :nombre = 22135323.12554:
    #  imageoo2 = 22135323.125539999455213546752929687500000000...
    # ...00000000000000000000000000000000000000000000000000000000
    """."""
    # Parenthèses non gérées
    nombre = '-.5 ** 2'
     
    # Mathématique sur nombres
    opsigne = ['+', '-', '*', '/', '%', '**', '//']  # Signes math
    opforme = ['(', ')', '=']  # Formes math
    opserie = []  # Collecte éléments
    opombre = ['']
    nn0 = nn1 = nn2 = 0
    oo0 = oo1 = ''
    for no in nombre:
        oo0 += no
        nn2 += 1
        if no in opsigne and nn0 != 0 \
                and len(oo1) < 2:
            oo1 += no
            pp = len(oo0) - 1
            if oo1 in opsigne:
                if nn1 == 0:
                    opserie.append(oo0[:pp])
            oo0 = ''
            if oo1 not in opsigne and len(oo1) > 1:
                oo0 = oo1[1]
                oo1 = oo1[0]
                nn1 = 1
            nn1 = 1
        elif no in opforme:  # Gestion paranthèse
            pass
        elif no == ' ':  # Gestion espace blanc
            pass
        else:
            if nn1 == 1:
                opserie.append(oo1)
                oo1 = ''
                nn1 = 0
        nn0 += 1
        if len(nombre) == nn2 and oo0 \
                and oo0 != nombre:
            opserie.append(oo0)
    # Série opération
    if opserie:
        opera(opserie)
    if opombre[0] != '':
        nombre = opombre[0]
    # Séparation décimale pour typage(%6)
    decim6 = [6]
    espec6(nombre)
    image = {0: 0}  # Dico.Nombre réel
    rondeur = {0: '', 1: 0}  # Dico.Comment
    entiere = {0: ''}  # Dico.Racine.Entier
    recital = [0]  # Table.Décimale
    nombre_carre(nombre)  # Appel principal
    if recital[0] != 0:
        recital[0] = str(image[0])[len(entiere[0]) + 1:]
    print('Rrecital =', recital[0], '\n...*')
    oo2 = image[0] ** 2
    if rondeur[1] == 1:
        oo2 = Decimal('-' + str(oo2))
    print('Iimageoo1 =', image[0], '\n..**',
          '\nIimageoo2 =', oo2)
    print('.***')
    if image[0]:
        if rondeur[0]:
            print('Rondeur 0:', rondeur[0])
        elif rondeur[2]:
            print('Rondeur 2:', rondeur[2], '\nReste =',
                  Decimal(nombre) - ((image[0]) ** 2))
        else:
            rondeur[0] = 'Valeur intervalle'
            print('Rondeur 0:', rondeur[0], '\nReste =',
                  Decimal(nombre) - ((image[0]) ** 2))
    else:
        if float(nombre) == 0:
            print('Rrondeur : Juste réro limite | zéro |')
        else:
            print('Rrondeur : Juste hors limite | premax |')
    # resume()
    #

  10. #10
    Invité
    Invité(e)
    Par défaut Dispatchage d'une équation inachevée
    Bonsoir

    Afin d'alléger le visuel donné par le code qui trie les éléments d'une équation suivants : Signes. Parenthèses.
    Ne sera présenté que le bout de code en question

    Le but est d'obtenir la séquence des opérations respectant la priorité principale des parenthèses, de relever les signes opératoires de l'équation, et qu'à chaque opération soit appliqué la précision décimale du module decimal. Mieux que l'instruction "eval", n'ayant pas cette précision, je présume.

    Pour l'instant, les nombres ou opérandes ne sont pas construits. Puis il reste à créer les valeurs intermédiaires avant d'obtenir le résultat final, sous la forme d'un nombre réel. Et aussi passer le cap de l'erreur actuelle, car la fonction decimal6 n'a pas de nombre à grignoter...

    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
    # Dispatchage d'une équation
    nombre = '(12*((-.5 ** -2)+(4+3 ))) -3'  # = -39.0
     
    # Mathématique sur nombres
    opsigne = ['+', '-', '%', '*', '/', '**', '//']  # Signes math
    opforme = ['(', ')', '=']   # Formes math
    opobjet = ''.join(str(o) for o in range(10))+'.'
    oparfer = []  # Parenthèses fermantes
    oparouv = []  # Parenthèses ouvrantes
    optrucs = []  # Collecte signes
    opblanc = []  # Collecte blancs
    opimage = []  # Points réalisés
    opserie = []  # Collecte nombres à calculer
    opombre = ['']  # Nombre calculé
    print('nombre =', nombre)
    n0n = 0
    for no in nombre:
        if no in opforme:
            if no == '(':
                oparouv.append(n0n)  # Contrôle parenthèses
            else:
                oparfer.append(n0n)
            opimage.append(no)
        elif no in opsigne:
            optrucs.append(n0n)
            opimage.append(no)
        elif no in opobjet:
            opimage.append(n0n)
        elif no == ' ':
            opblanc.append(n0n)
            opimage.append(no)
        n0n += 1
    print()
    print('oparouv', oparouv, 'oparfer', oparfer)
    print('optrucs', optrucs, 'opblanc', opblanc)
    print('opimage', opimage)
    print('______________________________',)
    # Positionnements des parenthèses ?(())?
    optotal = len(nombre)  # Blancs inclus
    oparent = len(oparouv)
    opstage = [[]] * oparent
    o1 = o3 = 0
    for ouv in range(oparent):
        o1 -= 1
        parouv = oparouv[o1]
        aro = o2 = parouv
        while o2 < optotal:
            aro += 1
            if aro in oparfer:
                for ops in opstage:
                    if aro in ops:
                        break
                else:
                    o3 -= 1
                    opstage[o3] = [parouv, aro]
                    break
            o2 += 1
    print('opstage',opstage)
    # Traitement des signes ?(**,//)?
    signes = []
    s0s = ''
    o0 = 0
    if optrucs:
        while 1:
            if o0 < len(optrucs) - 1 \
               and optrucs[o0+1] - optrucs[o0] == 1:
                s0s += nombre[optrucs[o0]]
                s0s += nombre[optrucs[o0+1]]
                if s0s in opsigne:
                    signes.append(s0s)
                    s0s = ''
                    o0 += 1
                else:
                    signes.append(s0s[:-1])
                    s0s = ''
            else:
                s0s += nombre[optrucs[o0]]
                signes.append(s0s)
                s0s = ''
            if o0 == len(optrucs)-1:
                print('SIG', signes)
                break
            o0 += 1
    À suivre

  11. #11
    Invité
    Invité(e)
    Par défaut Le puits des utilités
    Citation Envoyé par toumic Voir le message
    Bonsoir

    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
    # Dispatchage d'une équation
    nombre = '(12*((-.5 ** -2)+(4+3 ))) -3'  # = -39.0
     
    # Mathématique sur nombres
    opsigne = ['+', '-', '%', '*', '/', '**', '//']  # Signes math
    opforme = ['(', ')', '=']   # Formes math
    opobjet = ''.join(str(o) for o in range(10))+'.'
    oparfer = []  # Parenthèses fermantes
    oparouv = []  # Parenthèses ouvrantes
    optrucs = []  # Collecte signes
    opblanc = []  # Collecte blancs
    opimage = []  # Points réalisés
    opserie = []  # Collecte nombres à calculer
    opombre = ['']  # Nombre calculé
    print('nombre =', nombre)
    n0n = 0
    for no in nombre:
        if no in opforme:
            if no == '(':
                oparouv.append(n0n)  # Contrôle parenthèses
            else:
                oparfer.append(n0n)
            opimage.append(no)
        elif no in opsigne:
            optrucs.append(n0n)
            opimage.append(no)
        elif no in opobjet:
            opimage.append(n0n)
        elif no == ' ':
            opblanc.append(n0n)
            opimage.append(no)
        n0n += 1
    print()
    print('oparouv', oparouv, 'oparfer', oparfer)
    print('optrucs', optrucs, 'opblanc', opblanc)
    print('opimage', opimage)
    print('______________________________',)
    # Positionnements des parenthèses ?(())?
    optotal = len(nombre)  # Blancs inclus
    oparent = len(oparouv)
    opstage = [[]] * oparent
    o1 = o3 = 0
    for ouv in range(oparent):
        o1 -= 1
        parouv = oparouv[o1]
        aro = o2 = parouv
        while o2 < optotal:
            aro += 1
            if aro in oparfer:
                for ops in opstage:
                    if aro in ops:
                        break
                else:
                    o3 -= 1
                    opstage[o3] = [parouv, aro]
                    break
            o2 += 1
    print('opstage',opstage)
    # Traitement des signes ?(**,//)?
    signes = []
    s0s = ''
    o0 = 0
    if optrucs:
        while 1:
            if o0 < len(optrucs) - 1 \
               and optrucs[o0+1] - optrucs[o0] == 1:
                s0s += nombre[optrucs[o0]]
                s0s += nombre[optrucs[o0+1]]
                if s0s in opsigne:
                    signes.append(s0s)
                    s0s = ''
                    o0 += 1
                else:
                    signes.append(s0s[:-1])
                    s0s = ''
            else:
                s0s += nombre[optrucs[o0]]
                signes.append(s0s)
                s0s = ''
            if o0 == len(optrucs)-1:
                print('SIG', signes)
                break
            o0 += 1
    À suivre
    Bonjour
    Avec le nombre '(12*((m-.5 ** j-2)+(r4+3 )f)) -3$', ça marche aussi

  12. #12
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par toumic Voir le message
    Bonjour
    Avec le nombre '(12*((m-.5 ** j-2)+(r4+3 )f)) -3$', ça marche aussi
    La preu
    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
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Nombre au carré << nombre11carre.py >>
     
    from decimal import *
     
    def resume():
        print("""Le nombre_carre utilise le module decimal...
        La racine carrée réelle a forme générique
        Pour les opérations et les comparaisons
        Le traité se porte sur le nombre (ex:13.25)
        Les nombres négatifs en string dans le code
        Au vu du capable complexe de nombre_carre...
        Précision décimale aidant le nombre calculé
            La racine carrée réelle de : 3**2
            ou bien de : (42-32)**-2
        Prémice de nouvelles formes opératoires
        Autorités en terme général tant que logiques""")
     
    def espec6(ome):
        """ Séparation décimale pour typage(%6)
        # *(_TableTypeGénéral = [0,1,2,3,4,5]_)*
        # Type 6: Supérieur à *(_TTG_)"""
        # Recherche du point décimal
        if '.' in ome:
            nentie = 0  # Poids.Entier.fort
            for me in ome:
                nentie += 1
                if me == '.':
                    break
        else:
            # Nombre.Entier
            nentie = len(str(int(ome)))  # Poids.Entier.faible
        nmasse = len(ome)  # Masse.Nombre
        nmedif = nmasse - nentie  # Mesure.Decimale
        ndecim = ome[nentie:]  # Masse.Decimale
        # Mesure.Decimale
        if nmedif != 0:
            fnd = 0
            for nd in ndecim:
                fnd += int(nd)  # Addition ndecim(nd)
                if fnd != 0:  # Somme positive
                    decim6[0] = int(ndecim) % 6
                    # Condition nombre négatif
                    if ome[0] == '-':
                        decim6[0] = int(str('-' + str(decim6[0])))
                    break
     
    def opera(nop):
        """Fonction opératoire"""
        def addition(i, j):
            return i + j
        def soustraction(i, j):
            return i - j
        def multiplie(i, j):
            return i * j
        def expose(i, j):
            return i ** j
        def division(i, j):
            return i / j
        def diventier(i, j):
            return i // j
        def modulo(i, j):
            return i % j
        signe = {'+': addition, '-': soustraction, '*': multiplie,
                 '**': expose, '/': division, '//': diventier,
                 '%': modulo}
        getcontext().prec = len(nop) * 50
        nbr1 = Decimal(nop[0])
        operation = signe[nop[1]]
        nbr2 = Decimal(nop[2])
        opombre[0] = str(operation(nbr1, nbr2))
        if 'E' in opombre[0] or 'e' in opombre[0]:
            op_e = []
            op_o = len(opombre[0])
            for ie in range(op_o - 1, 0, -1):
                if opombre[0][ie] in ("E", '+', '-'):
                    break
                else:
                    op_e.append(opombre[0][ie])
            op_r = list(reversed(op_e))
            op_j = (''.join(str(o0a) for o0a in op_r))
            getcontext().prec = int(op_j) + op_o
            opombre[0] = str(operation(nbr1, nbr2))
     
    def nombre_carre(nbr):
        """ Cette fonction produit la racine carrée du nombre, et
        elle commence par définir la partie entière de la racine².
        Qui en général a une virgule  flottante ( point  décimal )
        La polarité du nombre signé, forme une transition (+-)
            Analyse de la surface(Typique = Nombre % 6)
                1 = 7 % 6       :7%6: Pôle positif naturel
                -1 = -7 % -6    :-7%-6: Pôle négatif naturel
                5 = -7 % 6      :-7%6: Transit positif naturel
                -5 = 7 % -6     :7%-6: Transit négatif naturel
        """
        nbr = Decimal(nbr)
        if nbr <= -0:
            nbr = Decimal(str(nbr)[1:])
            rondeur[1] = 1
        # Précision.Allusion.Illusion.
        premax = 100000000
        """ Modulation unaire"""
        if len(str(nbr)) < 10:
            precision = (len(str(nbr)) + 1) * 10
            precisive = '(*10)'
        elif 10 <= len(str(nbr)) < 50:
            precision = int(len(str(nbr)) ** 2)
            precisive = '(**2)'
        elif 50 <= len(str(nbr)) < 100:
            precision = int(len(str(nbr)) ** 1.75)
            precisive = '(**1.75)'
        elif 100 <= (int(len(str(nbr)))) < premax:
            precision = int(len(str(nbr)) ** 1.25)
            precisive = '(**1.25)'
        else:
            return
        getcontext().prec = precision
        # Maximum(machine locale) = 100000000
        # Racine² décimale entière
        wh = int(nbr ** Decimal(.5))
        wh0 = (nbr ** Decimal(.5))
        nbu = nbr
        # Secteur décimal
        decitab = []
        if rondeur[1] == 1:
            entiere[0] = str('-' + str(wh))
        else:
            entiere[0] = str(wh)
        print('entiere =', entiere[0])
        www = nbrdec = nc = top = 0
        while image[0] ** 2 <= nbr and top == 0:
            for img in range(1, 10):
                if decitab:
                    image[0] = Decimal(entiere[0] + '.' + recital[0] + str(img))
                else:
                    if not nc:
                        nbrdec += 1  # Unité décimale
                        nc = 1
                    image[0] = Decimal(entiere[0] + '.' + str(img))
                if image[0] ** 2 > nbr:
                    decitab.append(img - 1)
                    nbrdec += 1  # Nombre de décimales
                    recital[0] = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(entiere[0] + '.' + recital[0])
                    if image[0] ** 2 == nbr:
                        rondeur[0] = 'Juste racine² | nbr |'
                        top = 1
                        break
                    break
                elif img == 9:
                    if image[0] ** 2 == nbr:
                        rondeur[0] = 'Juste racine² | i9 |'
                        top = 1
                        break
                    decitab.append(img)
                    nbrdec += 1  # Nombre de décimales
                    recital[0] = (''.join(str(d) for d in decitab))
                    image[0] = Decimal(entiere[0] + '.' + recital[0])
                elif image[0] ** 2 == nbr:
                    rondeur[0] = 'Juste racine² | elif |'
                    top = 1
                    recital[0] = str(image[0])[len(entiere[0]) + 1:]
                    break
            # print(www, '°°° **2 =', image[0] ** 2)
            www += 1
        else:
            if len(str(rondeur[0])) < 1:
                rondeur[2] = 'Variant racine² | not |'
            nb0 = str(int(nbr) % 6)
            if rondeur[1] == 1:
                nbr = Decimal('-' + str(nbr))
                wh0 = Decimal('-' + str(wh0))
                nb0 = '-' + nb0
            sq0 = wh0
            if decim6[0] < 6:
                print('Rnombre =', nbr, ';typo =', [nb0,
                                                    '.', str(decim6[0])])
            else:
                print('Rnombre =', nbr, ';typo =', [nb0])
            if sq0 ** 2 == nbu:
                print('_Rreelle_juste =', sq0)
            else:
                print('_Rracine =', sq0)
            print('*... (', nbrdec, ') Precision', precision, precisive)
     
    # Nombre a forme décimale __________________________________
    """ Une décimale au format texte a un meilleur suivi """
    # :nombre = '22135323.12554':
    #  imageoo2 = 22135323.125540000000000000000000000000000000...
    # ...00000000000000000000000000000000000000000000000000000000
    # :nombre = 22135323.12554:
    #  imageoo2 = 22135323.125539999455213546752929687500000000...
    # ...00000000000000000000000000000000000000000000000000000000
    """."""  # __________________________________________________
    # Dispatchage d'une équation
    nombre = '425+ù((42-32)**-2 )_ '  # = 0.01
    nombre = '(' + nombre + ')'  # Englobement parenthèses
    # '16*(12**((5 ** -2)*8))'  # = 35.437084273926715
     
    # Mathématique sur nombres
    opsigne = ['+', '-', '%', '*', '/', '**', '//']  # Signes math
    opforme = ['(', ')', '=']  # Formes math
    opobjet = ''.join(str(o) for o in range(10)) + '.'
    oparfer = []  # Parenthèses fermantes
    oparouv = []  # Parenthèses ouvrantes
    optrucs = []  # Collecte signes
    opblanc = []  # Collecte blancs
    opautre = []  # Collecte autres
    opchiff = []  # Collecte chiffres
    opimage = []  # Points réalisés
    opserie = {}  # Collecte nombres à calculer
    opombre = ['']  # Nombre calculé
    print('nombre =', nombre)
    # Décomposition du nombre
    n0n = 0
    for no in nombre:
        if no in opforme:
            if no == '(':
                oparouv.append(n0n)  # Contrôle parenthèses
            else:
                oparfer.append(n0n)
            opimage.append(no)
        elif no in opsigne:
            optrucs.append(n0n)
            opimage.append(no)
        elif no in opobjet:
            opchiff.append(n0n)
            opimage.append(n0n)
        elif no == ' ':
            opblanc.append(n0n)
            opimage.append(no)
        else:
            opautre.append(n0n)
            opimage.append(no)
        n0n += 1
    print()
    print('oparouv', oparouv, 'oparfer', oparfer)
    print('optrucs', optrucs, 'opblanc', opblanc)
    print('opimage', opimage, '\nopchiff', opchiff,
          'opautre', opautre)
    print('______________________________', )
    # Positionnements des parenthèses ?(())?
    optotal = len(nombre)  # Blancs inclus
    oparent = len(oparouv)
    opstage = [[]] * oparent
    rentage = []
    o1 = o3 = 0
    for ouv in range(oparent):
        o1 -= 1
        parouv = oparouv[o1]
        aro = o2 = parouv
        while o2 < optotal:
            aro += 1
            if aro in oparfer:
                for ops in opstage:
                    if aro in ops:
                        break
                else:
                    o3 -= 1
                    opstage[o3] = [parouv, aro]
                    break
            o2 += 1
    # Traitement des signes ?(**,//)?
    signes = []
    s0s = s1s = ''
    o0 = 0
    if optrucs:
        while 1:
            if o0 < len(optrucs) - 1 \
                    and optrucs[o0 + 1] - optrucs[o0] == 1:
                s0s += nombre[optrucs[o0]]
                s0s += nombre[optrucs[o0 + 1]]
                if s0s in opsigne:
                    s1s = optrucs[o0], s0s
                    signes.append(s1s)
                    s0s = ''
                    o0 += 1
                else:
                    s1s = optrucs[o0], s0s[:-1]
                    signes.append(s1s)
                    s0s = ''
            else:
                s0s += nombre[optrucs[o0]]
                s1s = optrucs[o0], s0s
                signes.append(s1s)
                s0s = ''
            if o0 == len(optrucs) - 1:
                print('signes =', signes)
                break
            o0 += 1
    # Composition des plages opérationnelles
    if opstage:
        opnuage = {}  # Espace opérationnel
        opcompe = []  # Plagiat des plages
        # Nombre avant la première parenthèse
        if oparouv and min(oparouv) != 0:
            opzerie = []
            for oz in range(min(oparouv)):
                opzerie.append(oz)
            opnuage[0] = opzerie
        # Nombre après la dernière parenthèse
        if max(opchiff) > max(oparfer):
            opzerie = []
            for oz in range(max(oparfer), max(opchiff) + 1):
                opzerie.append(oz)
            opnuage[max(oparfer)] = opzerie
        # Production des plages opérationnelles
        opstage.reverse()
        for oprev in opstage:
            optreve = []
            for rev in range(min(oprev), max(oprev) + 1):
                if rev not in opcompe:
                    opcompe.append(rev)
                    optreve.append(rev)
                # else: rev a sa plage
            opnuage[min(oprev)] = optreve
            rentage.append(oprev[0])
        # Lecture de l'image opérationnelle
        for eve, ver in opnuage.items():
            opono = []
            ono = ''
            o0o = 0
            for opv in ver[1:]:
                if opimage[opv] in opchiff:
                    ono += nombre[opimage[opv]]
                elif opv in optrucs:
                    if ono:
                        opono.append(ono)
                    for truc in signes:
                        if opv in truc:
                            if opv - 1 in optrucs:
                                ono += truc[1]
                                o0o = 1
                            else:
                                opono.append(truc[1])
                    if not o0o:
                        ono = ''
            if ono:
                opono.append(ono)
            if opono:
                if 1 < len(opono) < 3:
                    if opono[0] in opsigne:
                        opono = ver[0], 'gnon', opono
                    else:
                        opono = ver[0], 'dnon', opono
                else:
                    opono = ver[0], 'oui', opono
                opserie[opono[0]] = opono[1:]
            else:
                opono = []
        if opserie:
            o1o = 0
            for oo in rentage:
                if opserie[oo][0][1:] == 'non':
                    if opombre[0]:
                        if opserie[oo][0][:-3] == 'g':
                            opgrade = [opombre[0]]
                            for opgr in opserie[oo][-1]:
                                opgrade.append(opgr)
                            opera(opgrade)
                        else:
                            opgrade = []
                            for opgr in opserie[oo][-1]:
                                opgrade.append(opgr)
                            opgrade.append(opombre[0])
                            opera(opgrade)
                else:
                    opera(opserie[oo][1])
    if opombre[0] != '':
        nombre = opombre[0]
    # Séparation décimale pour typage(%6)
    decim6 = [6]
    espec6(nombre)
    image = {0: 0}  # Dico.Nombre réel
    rondeur = {0: '', 1: 0}  # Dico.Comment
    entiere = {0: ''}  # Dico.Racine.Entier
    recital = [0]  # Table.Décimale
    nombre_carre(nombre)  # Appel principal
    if recital[0] != 0:
        recital[0] = str(image[0])[len(entiere[0]) + 1:]
    print('Rrecital =', recital[0], '\n...*')
    oo2 = image[0] ** 2
    if rondeur[1] == 1:
        oo2 = Decimal('-' + str(oo2))
    print('Iimageoo1 =', image[0], '\n..**',
          '\nIimageoo2 =', oo2)
    print('.***')
    if image[0]:
        if rondeur[0]:
            print('Rondeur 0:', rondeur[0])
        elif rondeur[2]:
            print('Rondeur 2:', rondeur[2], '\nReste =',
                  Decimal(nombre) - ((image[0]) ** 2))
        else:
            rondeur[0] = 'Valeur intervalle'
            print('Rondeur 0:', rondeur[0], '\nReste =',
                  Decimal(nombre) - ((image[0]) ** 2))
    else:
        if float(nombre) == 0:
            print('Rrondeur : Juste réro limite | zéro |')
        else:
            print('Rrondeur : Juste hors limite | premax |')
    # resume()
    #
    ve...

    En mesure de résoudre cette affaire, celle des parenthèses ()...

    Le premier nombre équationnel était configuré ainsi : nombre = ' 18 + ( (3 * 5) * 18) '. Ou : n+((n*n)*n)...
    Il contenait des éléments de parenthèses aux qualités réparties ainsi : Chaque groupe équivalait à : Un nombre plus un opérateur (+,-,*,/,,,)...
    Le problème est apparu lorsque le nombre d'éléments entre parenthèses change, ainsi : ' 18 + ( (3 * 5) * (18 + 0) ) '. Ou : n+((n*n)*(n+n))...
    Cette équation a un signe unique comme élément de parenthèses : Et çà c'est une des résolutions, en rapport des retours calculés...

    En cours de répondre à l'effet des signatures négatives (-)...
    ..À
    , bientôt.
    Dernière modification par Invité ; 30/04/2018 à 07h53. Motif: Détection parenthèses à signe unique

Discussions similaires

  1. Calcul de la racine carrée d'un nombre
    Par Anomaly dans le forum Télécharger
    Réponses: 3
    Dernier message: 04/11/2013, 23h16
  2. Calculer la racine carrée d'un nombre d'une façon particulière
    Par Roud9 dans le forum Débuter avec Java
    Réponses: 8
    Dernier message: 29/09/2010, 03h11
  3. Nombre premiers et calculer la racine carrée d'un nombre
    Par Roud9 dans le forum Débuter avec Java
    Réponses: 19
    Dernier message: 21/09/2010, 17h55
  4. Racine carrée de très grands nombres
    Par paskal64 dans le forum Général Python
    Réponses: 5
    Dernier message: 19/08/2008, 08h35
  5. la racine carré d'un nombre
    Par aziz jim dans le forum C++
    Réponses: 4
    Dernier message: 07/08/2006, 14h31

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