[Regex] Une regex bien compliquée à construire...

[Aenonis]

Bonjour à tous et à toutes !

Je suis en train de réaliser un programme en C++ qui joue avec les nombres.

L'utilisateur entre une chaine de caractères et je dois vérifier le format avant de construire mon nombre sur la chaine qu'il m'a donnée.

La construction du nombre se fera après et sera grandement facilitée vue qu'on aura vérifié le format avant.

Pour l'instant, je vérifie le format à la main avec une fonction horrible qui joue avec les booléens, qui passent à vrai lorsqu'on est dans une condition et dans les autres conditions vérifie tel ou tel type de booléen, et renvoie faux dans le cas échéant. La fonction est affreuse et est fortement source aux bugs.

Pour info, je vous passe le code de la fonction:

 Cliquez pour afficher

bool Nombre::verifier_format(const string &nombre)
{
    #warning USE REGEX !
    bool exp=false;
    bool signe;
    bool have_signe_exp=false;
    bool have_signe_arithmetique=false;
    bool reel=false;
    bool nan_or_inf=false;
    bool parenthese_ouvrante=false;
    bool parenthese_fermante=false;
    size_t i=0;
    while (i<nombre.size())
    {
        bool nan=(nombre.substr(i, S_NaN.size())==S_NaN); //S_NaN est une constante de classe qui vaut "NaN"
        bool inf=(nombre.substr(i, S_INF.size())==S_INF); //S_INF est une constante de classe qui vaut "INF"
        if (nan || inf)
        {
            if (exp) return false;
            if (nan_or_inf) return false;
            if (nan && signe) return false;
            if (!parenthese_ouvrante)
            {
                if (have_signe_arithmetique)
                {
                    if (i!=1) return false;
                }
                else
                {
                    if (i!=0) return false;
                }
            }
            else
            {
                if (have_signe_arithmetique)
                {
                    if (i!=2) return false;
                }
                else
                {
                    if (i!=1) return false;
                }
            }
            nan_or_inf=true;
            if (nan) i+=S_NaN.size();
            else if (inf) i+=S_INF.size();
        }
        else
        {
            char c=nombre[i];
            if (c=='+' || c=='-')
            {
                if (exp)
                {
                    if (have_signe_exp) return false;
                    if (nombre[i-1]!='e') return false;
                    have_signe_exp=true;
                }
                else
                {
                    if (have_signe_arithmetique) return false;
                    if (parenthese_ouvrante)
                    {
                        if (i!=1) return false;
                    }
                    else
                    {
                        if (i!=0) return false;
                    }
                    have_signe_arithmetique=true;
                    signe=(c=='-');
                }
                ++i;
            }
            else if (c=='.' || c==',')
            {
                if (nan_or_inf) return false;
                if (reel) return false;
                if (exp) return false;
                if (i==nombre.size()-1) return false;
                reel=true;
                ++i;
            }
            else if (c=='(')
            {
                if (parenthese_fermante) return false;
                if (parenthese_ouvrante) return false;
                if (i!=0) return false;
                parenthese_ouvrante=true;
                ++i;
            }
            else if (c==')')
            {
                if (parenthese_fermante) return false;
                if (!parenthese_ouvrante) return false;
                parenthese_fermante=true;
                parenthese_ouvrante=false;
                ++i;
            }
            else if (c=='e')
            {
                if (exp) return false;
                if (!parenthese_ouvrante)
                {
                    if (have_signe_arithmetique)
                    {
                        if (i<=1) return false;
                    }
                    else
                    {
                        if (i<=0) return false;
                    }
                }
                else
                {
                    if (have_signe_arithmetique)
                    {
                        if (i<=2) return false;
                    }
                    else
                    {
                        if (i<=1) return false;
                    }
                }
                exp=true;
                ++i;
            }
            else if (c=='b' || c=='o' || c=='d' || c=='h')
            {
                if (parenthese_fermante) return false;
                if (parenthese_ouvrante) return false;
                if (i!=nombre.size()-1) return false;
                ++i;
            }
            else
            {
                if (nan_or_inf) return false;
                if (c=='[')
                {
                    if (parenthese_fermante) return false;
                    if (exp) return false;
                    ++i;
                    while (i<nombre.size())
                    {
                        c=nombre[i];
                        if (c==']') break;
                        else if (!(c>='0' && c<='9')) return false;
                        ++i;
                    }
                    if (i>=nombre.size()) return false;
                    c=nombre[i];
                    if (c!=']') return false;
                    ++i;
                }
                else if (c>='A' && c<='Z')
                {
                    if (parenthese_fermante) return false;
                    if (exp) return false;
                    ++i;
                }
                else if (c>='0' && c<='9')
                {
                    ++i;
                }
                else
                    return false;
            }
        }
    }
    if (exp && nombre[nombre.size()-1]=='e') return false;
    if (i==0 || parenthese_ouvrante) return false;
    return true;
}

Comme vous le voyez, il y a des if dans tous les sens et je peux très bien avoir oublié une condition quelque part sans m'en rendre compte.

Maintenant, je vais vous dire ce que fait ce code et les "règles" de la regex:

Ma chaine doit être de la forme:
- des chiffres (genre "12535")
- un signe '+' ou '-' en début de chaine ("-12532" ou "+12523")
- un point '.' ou une virgule ',' au milieu de la chaine ou au début, mais pas à la fin ("12125.256" ou "1254,855" ou encore ".0225")
- à la place des chiffres, on peut avoir des lettres majuscules ("ABGFS256")
- on peut aussi avoir des chiffres entre crochets ("[15]16[21]102")
- on peut avoir des lettres et des chiffres entre crochets dans la même chaine ("A[10]B01[15]")
- la chaine peut contenir la lettre minuscule 'e', si il y a le 'e', un nombre doit suivre le 'e', un signe peut être renseigné ('+' ou '-') mais doit suivre le 'e' (genre: "10e-32" ou "10e+32" ou encore "10e32")
- comme dernier caractère on peut avoir une base parmi les 4 lettres (minuscule obligatoirement) suivantes: 'b', 'o', 'd' ou 'h' (genre "ABC01DEFh")
- la chaine peut être entièrement (le signe avec) entre parenthèses, et si parenthèses il y a, un nombre (pas de signe!) doit suivre la parenthèse fermante (genre: "(-11001A[19]10)23") et si parenthèses, interdiction d'avoir une base à fin ('b', 'o', 'd' ou 'h')

Cas particuliers: le NaN et le INF
- On peut avoir NaN ou INF dans la chaine
Si on a NaN ou INF, on ne peut pas avoir:
- de chiffres
- de point ou de virgule
- de lettres
- des chiffres entre crochets
- de 'e'
Mais on peut avoir:
- un signe (uniquement pour le INF)
- une base
- les parenthèses

Cette fonction ne vérifie que le format, elle ne vérifie pas (une autre fonction s'en charge) si les nombres/lettres/nombres entre crochets sont plus petits que la base renseignée (genre "(0124)3", le 3 derrière la parenthèse signifie "en base 3", il y a un '4' dans la chaine et la base 3 n'accepte que les 0, les 1 et les 2).

Voilà.

Pour info, j'ai essayé d'aller sur le site du zéro mais il est en dérangement, donc pas moyen d'étudier les regex pour transformer ce code en une superbe regex, la regex de l'année.

En vous remerciant d'avance,

Aenonis
-----

[Aenonis]

Bonjour à toutes et à tous ^^

Je suis désolé de relancer le sujet mais je remarque qu'il n'a pas beaucoup de succès...

Ais-je fait quelque chose de contraire à la charte pour ne pas avoir de réponses?

Si oui, je ferai de mon mieux pour améliorer ma question.

Au plaisir,

Aenonis

[fred1599]

Ça fait longtemps que j'ai pas fais de C++, mais les templates ne sont pas spécifiques à la générécité?

[Aenonis]

Je te remercie pour ta réponse mais je me demande ce que les templates viennent faire là-dedans.

Je n'utilise pas de template, je veux juste valider une chaine de caractère avec une regex...

Le code que j'ai linké le fait assez bien mais c'est tordu et source au bugs...

Au plaisir,

Aenonis

PS: la notion de regex n'est pas propre au C++, on peut jouer avec les regex dans n'importe quel langage vu que les regex est un "langage" à part entière... il existe le POSIX et le PREG (comme normes)

[A voir en vidéo sur Futura]

[fred1599]

exact j'avais pas lu la suite du problème, ça m'apprendra... Si j'ai le temps je regarderais.

[Aenonis]

Je te remercie,

S'il y a d'autres forumeurs qui veulent se pencher sur mon cas, j'en serais plus que ravi

Au plaisir,

Aenonis

[fred1599]

Pour être précis, tu crées un parser sur une chaîne, c'est ça? Et tu veux utiliser les regex pour le faire?

[Aenonis]

En fait, le truc, c'est que mon constructeur principal de ma classe Nombre attend une chaine pour que je puisse construire mon nombre en interne.

Pour que ma fonction qui construit mon instance de nombre fonctionne bien, il faut que la chaine ait un certain format pour que ma fonction sache sur quoi elle travaille et qu'elle ne travaille pas sur n'importe quoi.

J'utilise des nombres "évolués" donc, des nombres simples auxquels j'ai ajouté différentes règles, telles que les bases, les nombres entre crochets, etc...

Si je fournis la chaine "Salut, je m'appelle Aenonis" à ma classe, elle ne saura pas quoi en faire vu que ce n'est pas un nombre.

Un nombre simple est de la forme: "10.251" avec un signe ('+' ou '-') devant et le point peut être une virgule. Tout chiffre peut être remplacé par une lettre ou un nombre entre crochets, genre, si on est en base 16, on peut utiliser les lettres de 'A' à 'F' et en base 40 les nombres entre crochets de [11] à [39]. Si on veut renseigner une base, on peut soit le faire en mettant une lettre à la fin du nombre ('b' pour binaire, 'o' pour octal, 'd' pour décimal [c'est par défaut] et 'h' pour hexadécimal) ou pour une base quelconque, mettre tout le nombre entre parenthèses suivi de la base, par exemple pour la base 40 "(10[19])40", cela signifie, je veux le nombre '1', '0', '19' en base 40, évidemment, les deux systèmes de renseignement de bases sont exclusives, soit l'un, soit l'autre. De plus, on peut utiliser la notation "exponentielle" avec le petit 'e' pour multiplier ou diviser le nombre par [la base] exposant [ce qui suit le 'e'], exemple, "22e2" vaut "2200" et "2200e-2" vaut "22", le signe '+' peut être également renseigné à place du '-'. De plus, on peut renseigner un "NaN" (Not a Number) qui peut être basé mais non signé ainsi qu'un INF (l'infini) qui peut être basé et également signé.

La construction du nombre fonctionne très bien sur une chaine "correctement formée", la fonction que j'ai linké effectue tous le tests nécessaires pour vérifier la bonne formation mais comme je l'ai dit plus haut, cette fonction est sujette aux bugs et si je veux ajouter une règle, je dois faire dix mille modifications en espérant ne rien avoir oublié. Donc, en passant par une regex, les risques de bugs sont fortement réduits.

Au plaisir,

Aenonis

[Aenonis]

Je me permet de relancer le sujet.

[lou_ibmix_xi]

1ère remarque, pour alléger ton écriture:
utilises "switch / case" à la place de tes "if else"
teste les conditions fausses en premier pour sortir directement et éviter ainsi les indentations, exemple:

if (condition_a_filter == true) {
   return -1;
}
/* le code continue car condition normal, on gagne une indentation */

2ème remarque, qui n'est pas forcément valable si c'est un exercice: quand on développe du logiciel, il ne faut pas réinventer la roue mais utiliser ce qui existe déjà, notamment les fonctions de type "atof", "strtol", "isalnum" etc... Attention, ce sont des fonctions de la bibliothèque standard C, tu utilises du C++, cherche pour des fonctions de la bibliothèque standard C++.

Et j'oubliai, les expressions régulières sont nettement plus puissantes (et compliquées) que ce type d'utilisation, en gros tu veux utiliser un marteau piqueur pour écraser une mouche, mais si vraiment tu veux utiliser de l'expression régulière, je suis sûr que tu trouveras des bibliothèques en C++ qui te mâcheront le bouleau.

[Aenonis]

J'utilise boost pour les regex...

Je viens de voir les 3 fonctions de la bibliothèque standard, il est vrai qu'elles me seront sûrement utiles mais, le truc, c'est que ma classe nombre ne joue pas avec les types primitifs...
Elle a une liste chainée en interne, genre le nombre "2042", est stocké sous la forme {2, 0, 4, 2} en mémoire (sans trop entrer dans les détails), la transformation de la chaine en liste se fait très bien, c'est juste la fonction de validation qui est houleuse...

En te remerciant,

Aenonis

[lou_ibmix_xi]

En relisant rapidement tes deux discussions, je pense que tu attaques "naïvement" un problème qui peut difficilement être géré aussi simplement (à mon sens)... Attention, aller à la solution naïve est un bon réflexe (une solution simple est plus facile à coder, donc plus rapide à mettre en place et moins de bugs...), surtout si en plus c'est un exercice (c'est très formateur de comprendre ses erreurs).

Donc, je pense qu'il serait bon que tu écrives un "cahier des charges fonctionel" (à quel(s) besoin(s) ton programme doit répondre), où s'il est suffisament clair dans ta tête, que tu nous l'expose pour que l'on puisse te guider sur le "comment faire".

En effet, il y a très peu de domaines pour les-quels une précision pareille est nécessaire, à titre d'exemple, 39 chiffres significatifs de PI suffisent pour calculer la circonférence de l'univers avec une précision d'un atome d'hydrogène... Cette simple phrase contient un mot clef intéressant pour ton cas: chiffres significatifs, qui peut te guider sur d'autres moyens d'encoder tes nombres de manière plus efficace en occupation mémoire (virgules flottantes, partie entière + fraction...), au détriment de la précision.
Une autre illustration, MATLAB (qui est une référence du calcul numérique) n'utilise "que" du double précision (donc 64 bits).

De plus il faut avoir conscience que multiplier 2 nombres à N décimales donne un résultat de à 2N décimales, je te laisse imaginer pour les puissances et autres exponentielles, tes besoins mémoires vont exploser rapidement, même si tu dispose de 128To de RAM. Une autre remarque, il me semblerait opportun de dissocier les entrées - sorties de ton programme du traitement interne, je veux dire par là que je vois mal l'intérêt d'analyser une chaîne de plus d'une dizaine de caractères puisque c'est un humain qui va l'écrire, et des nombres de plus d'une dizaine de caractères sont em****ant à écrire, sujet à erreur etc... Et lorsque l'entrée de viendra pas d'un humain (ou lorsque la sortie ne sera pas destinée à un humain), tu choisiras un format de stockage/échange binaire pour te simplifier la tâche (sans parler du gain en mémoire).

Je ne connais pas ton niveau ni ta "culture" informatique, mais je pense que comprendre le fonctionnement des nombres flottants (ieee 754 par exemple), et l'encodage en virgule fixe peuvent te faire toucher du doigt des problématiques (dynamique, précision) auquelles tu vas être confronté.

Si vraiment tu as un tel besoin, jette un oeil à la "GNU MP Bignum library" qui ressemble à ce que tu cherches à faire... sans forcément rentrer dans le code, je pense qu'en fouillant un peu tu devrais trouver des papiers expliquant l'architecture et pourquoi ils ont choisi ces solutions plutôt que d'autres. D'autre projet peuvent te guider sur des pistes potentielles, je pense notamment aux programmes qui calculent PI avec des milliards de chiffres après la virgule.

[lou_ibmix_xi]

J'utilise boost pour les regex...

C'est un bon réflexe d'utiliser une bibliothèque existante, mais je persiste, faire du regex pour un simple

[+-]?[0-9]*\.?[0-9]*[eE]?[0-9]*

(vite faite par un non-spécialiste donc ya peut-être des erreurs), c'est comme aller au boulot en F1, c'est faisable mais pas forcément pertinant...

Je viens de voir les 3 fonctions de la bibliothèque standard, il est vrai qu'elles me seront sûrement utiles mais, le truc, c'est que ma classe nombre ne joue pas avec les types primitifs...

Mais il y a peut-être un moyen de les combiner pour faire ce que tu veux (c'est une vrai question), plutôt que tout te palucher avec ta formule 1 regex?

[Aenonis]

Bonjour Cher lou_ibmix_xi,

Merci de t'attarder sur mon problème .

En fait, le truc, c'est pas vraiment ce qui a après la virgule ce qui m’intéresse, c'est la partie entière. Quand je dis, un nombre à 10.000.000 de chiffres, c'est réellement un nombre avec sa partie entière à 10.000.000 de chiffres, ce qui a derrière la virgule est limitée à 110 chiffres (genre, si on demande 1/3, que le programme ne boucle pas à ajouter des 3 à l'infini).

Ce qui important à savoir, vu que tu me demandes comment je gère mes nombres afin que tu puisses m'aider, c'est que je code mes nombres dans la base demandée et je fais tous les calculs (+, -, * et /) dans la base demandée, sur base du calcul écrit (addition écrite, soustraction écrite, multiplication écrite, division écrite).

Je gère la virgule en ajoutant un "-1" dans ma liste.

Avant de faire l'opération, je mets mes deux nombres "à la même taille" genre, si j'ai 3.25 et 14.6, je dois mettre 3.25 à 03.25 et 14.6 à 14.60, une fois ceci fait, j'enlève la virgule aux deux nombres, donc ça revient à 0325 et 1460 et puis j’exécute l'algorithme de l'opération écrite.
À la fin, je rajoute la virgule à sa bonne place dans le nombre résultat.

Voici à titre informatif l'algorithme de l'addition:

Je met le nombre1 à la taille size+1
i <- 0
tant que i plus petit que size faire
	nombre1[i] <- nombre1[i] + nombre2[i]
	nombre1[i+1] <- nombre1[i+1] + (nombre1[i] DIV base)
	nombre1[i] <- nombre1[i] MOD base
fin tanque
resultat est dans nombre1

Comme tu vois, c'est exactement l'addition écrite.
Dans mon exemple, si nombre1=0325 et nombre2=1460, le résultat vaudra 1785, après évidemment je remets la virgule à la bonne place: 17.85.

Les 4 opérations de base fonctionnent comme ça.

Mon programme gère également les changements de base, genre, je peux demander au programme de me transformer "123" en hexadécimal et faire les calculs en base 16. Ou encore transformer en base X et faire les calculs en base X.

Si deux nombres sont de base différentes et que je veux les additionner par exemple, l'opérateur + (nombre1+nombre2) transforme le nombre2 en la base du nombre1 et envoie les deux nombres à l'algo d'addition.

La multiplication double la taille du résultat et la division s'arrête à 110 décimales.

Dans ce modèle, la taille est "infinie".

Mais vu que l'infini n'est pas informatique, je suis coincé par la mémoire, surtout en RAM.

J'ai pensé à autre chose: que ma classe nombre n'ai rien comme attribut si ce n'est que des noms de fichiers (une liste de noms de fichiers) et dans les fichiers les données du nombre, si le nombre fait 100 Go par exemple, je le partitionne en 200 fichiers de 512 Mo, mais ce sera pour les opérations que ce sera difficile à gérer, je ne peux pas avoir plus d'un fichier en mémoire (ou deux dans le cas d'une opération), la multiplication par exemple a besoin de toutes les données pour fonctionner... donc ça va pas le faire.

Voilà, je t'ai expliqué en bref comment fonctionnait ma classe nombre, les tenants et aboutissants,

Au plaisir,

Aenonis

[Tryph]

salut,

je ne vais hélas pas pouvoir t'aider sur ton problème, mais à la lecture de tes différents posts ma curiosité s'aiguise:
pour quelle raison peut on avoir besoin de faire des calculs sur des nombre de plusieurs millions de chiffres?

c'est juste une sorte d'exercice, un défit personnel ou y a une réelle utilité derrière?

[Aenonis]

Salut Tryph,

Il n'y a pas de réelle utilité derrière, c'est juste que je n'aime pas la perte de précision lors de mes calculs, genre, 1024^1024 codé sur un "int" sur 32 bits, renverra une valeur non représentable sur 32 bits.

C'est pas un défi à proprement parlé mais j'ai toujours adoré la précision, l'exactitude. Au final, mon programme pourra comprendre une expression du genre "-1024^1024-2e+200+1001001b+-AB01h/sqrt(5.567o)", mais je dois d'abord décomposer le problème en écrivant d'abord ma classe Nombre qui gèrera les nombres.

Pour le moment, ma classe Expression travaille avec des "long double" donc est tout à fait capable de comprendre ce genre de charabia mais il y a perte de précision lors des calculs (vu qu'un long double est limité).

Au final, je devrai transformer mes "long double" en "Nombre" pour que l'expression retourne un nombre exact.

Le truc aussi, c'est que je déteste le plantage de programme alors que je n'y suis pour rien, si l'utilisateur veut jouer avec des nombres à 1.000.000.000 de chiffres, c'est son problème, genre le nombre "1e1000000000" fait planter royalement mon programme.

Je dois donc palier au problème de place dans la RAM ou alors bêtement envoyer une exception "NumberTooBiggerException" si on dépasse le million de chiffres, mais ça va faire tâche pour une classe qui est censée travailler avec des nombres de taille "infinie".

Si le programme plante parce que j'ai fait une erreur de programmation là d'accord, mais là, c'est un problème auquel je n'ai jamais réellement été confronté ou confronté mais jamais géré, et j'aimerai le gérer une bonne fois pour toutes.

Au plaisir,

Aenonis

[lou_ibmix_xi]

J'ai lu en diagonale tes 2 derniers postes, première remarque, il y a une incompréhension sur ce qu'est une base (décimale, binaire, octale ...), soit je n'ai pas compris ce que tu racontes, soit tu n'as pas compris qu'une base est une REPRESENTATION d'une valeur, donc ça n'a aucun sens de faire des calculs en hexa puisque tes nombres sont manipulés par le processeur qui les "stocke" en binaire...

Et une nouvelle couche sur la finalité, précision (ou dynamique plutôt dans ton cas) c'est un peu la même chose, et tu le saurais si tu t'étais intéressé aux formats virgule flottant et fixe comme je te le conseillai tu l'aurai sans doute compris... Donc je mettais en doute la pertinance d'une telle précision, de la même manière je mets en doute sur la pertinance d'une telle dynamique, ca même si tu avais besoin de compter tous les atomes de l'univers visible, tu arriverais à quelque chose autour de 10^80, et même si tu additionnes le nb total d'atome de l'univers visible toutes les secondes depuis la création de l'univers, un 10^100 te laisse une marge de manoeuvre de quelques milliards d'années... Donc 1024^1024, qui semble être un petit nombre pour toi, est un monstre que tu ne croisera jamais dans la réalité physique...

Reste les mathématiques, sauf que là encore, si tu cherches la précision absolue, tu travailles en formel (ou symbolique je ne sais jamais)... Alros peut-être que oui il y a la cryptographie où le besoin de gros nombre est essentiel, mais même là, une clef de 1024 bits tu arrives à des nombre en 10^308, là encore minuscule par rapport à ce que tu imagines faire...

En conclusion, tu t'attaques à problème qui n'est pas trivial, dont la pertinance est plus que discutable, avec des lacunes sur la réalité des représentations des nombres (de ce que je comprends de tes postes). Je n'essaye pas de te décourager, bien au contraire (c'est en mettant les mains dans le cambouis qu'on comprends le mieux les choses), sauf que tu mets la charrue avant les boeufs, et fais toi une culture dans ce domaine pour mieux comprendre les pourquoi du comment, et si c'est pour un besoin réel, il y a déjà des choses qui existent (je t'ai cité GMP la dernière fois, il y en a peut-être d'autre), utilises les, et/ou regardes comment d'autres ont fait...

[Aenonis]

Je te remercie.

Je sais que les bases est une représentation d'un nombre.

Prenons par exemple dans mon cas le nombre "10" en décimal.
En binaire, ça vaut "1010b".
En octal, "12o".
En hexadécimal, "Ah".

Je ne sais pas si tu te souviens de tes cours de primaire, mais les calculs écrits se font généralement en base 10.
Prenons le cas simple de l'addition (dont j'ai donné l'algo deux posts plus haut).
Pour une addition écrite, il faut additionner les deux premiers chiffres, plus le report si il y a, mettre un report au rang suivant si l'addition dépasse 10, et faire la même chose jusqu'au rang N.

Moi dans mon programme, j'ai généralisé l'addition écrite à la base X.

Dans ma représentation, j'ai des listes, dans le cas du "10":
En décimal: [1, 0].
En binaire: [1, 0, 1, 0].
En octal: [1, 2].
En hexadécimal: [10].
L'addition généralisée fonctionnera quelque soit la base dans laquelle le nombre est représenté.

Je sais que le CPU ne comprend que les '0' et les '1' mais dans mon format, on peut faire des opérations dans n'importe quelle base, on n'est pas obligé de passer par le binaire si on ne fait que de la base 10.

On peut demander explicitement à mon programme de faire les calculs en binaire/octal/hexadécimal en faisant:

Nombre nombre=Nombre("10"); //nombre vaut "10", [1, 0] en mémoire
Nombre binaire=nombre.toBase(2); //binaire vaut "1010b", [1, 0, 1, 0] en mémoire
++binaire; //on incrémente en binaire => binaire vaut "1011b", [1, 0, 1, 1] en mémoire
Nombre octal=nombre.toBase(8); //octal vaut "12o", [1, 2] en mémoire
++octal; //on incrémente en octal => octal vaut "13o", [1, 3] en mémoire
Nombre hexa=nombre.toBase(16); //hexa vaut "Ah", [10] en mémoire
++hexa; //on incrémente en hexa => hexa vaut "Bh", [11] en mémoire
++nombre; //on incrémente en décimal => nombre vaut "11", [1, 1] en mémoire

Sinon, quant à la représentation des nombres, tu me dis que j'ai des lacunes.
Je ne suis pas d'accord.
J'ai ma propre représentation en interne (comme je viens de l'expliquer) et, j'ai appris le IEEE lors de mes études, donc, je sais de quoi ça parle.

Amicalement,

Aenonis

[lou_ibmix_xi]

Je ne sais pas si tu te souviens de tes cours de primaire, mais les calculs écrits se font généralement en base 10.

[CYNISME]Ah bon? et bien moi je compte jusqu'à 1023 avec mes 10 doigts, et ça je ne l'ai pas appris au primaire[/CYNISME]

Dans ma représentation, j'ai des listes, dans le cas du "10":
En décimal: [1, 0].
En binaire: [1, 0, 1, 0].
En octal: [1, 2].
En hexadécimal: [10].
L'addition généralisée fonctionnera quelque soit la base dans laquelle le nombre est représenté.

Donc, tu utilises un entier (32 ou 64 bits) par symbole... Un symbole binaire nécessite 1 bit (donc une sur-occupation mémoire d'un rapport 32!), un symbole octale nécessite 3 bits pour être encodé, ..., un symbole hexadécimale nécessite 4 bits (donc une sur-occupation mémoire d'un rapport 8!), j'avais cru comprendre que tu avais des problèmes de mémoires...

Je sais que le CPU ne comprend que les '0' et les '1' mais dans mon format, on peut faire des opérations dans n'importe quelle base, on n'est pas obligé de passer par le binaire si on ne fait que de la base 10.

Mouais, mais tu n'as pas compris qu'utiliser une base plutôt qu'une autre n'a d'intérêt *que* pour les entrées-sorties pour un humain! Quel est l'intérêt de faire un calcul en base 10, si ce n'est faire faire du boulot inutile à la CPU (et s'em**rder à recoder des choses qui sont faites par la CPU)? A ton avis, pourquoi dans *toutes* les bibliothèques que tu croiseras la notion de base n'intervient qu'au moment des conversions "chaîne de caractère" -> entier informatique et vice-versa? Donc, lorsque on veut travailler avec des graaaands nombres (ou bien une graaaaande précision), l'entier devient le symbole, et le reste apparament tu le sais, une fois que tu es arrivé à 2^32 - 1, ton symbole de droite repasse à zéro, et tu incrémentes ton symbole de gauche. Mais ça tu l'aurais compris si tu étais allé voir gmp ou autres bibliothèques écrites par des gens dont c'est le boulot, et qui s'appuient sur les travaux de leurs prédécesseurs dont les résultats prouvent que ça ne marche pas trop mal...

Sinon, quant à la représentation des nombres, tu me dis que j'ai des lacunes.
Je ne suis pas d'accord.
J'ai ma propre représentation en interne (comme je viens de l'expliquer) et, j'ai appris le IEEE lors de mes études, donc, je sais de quoi ça parle.

[CYNISME]Mouiap, tu connais la norme ieee754 par coeur, et tu as inventé une facon révolutionaire d'encoder les nombres, j'espère que tu as déposé le brevet avant d'exposer tout ça sur le forum...[/CYNISME]
Il y a 2 types de représentation pour un nombre:
- la virgule flottante (dont ieee754 est un exemple), la dynamique est variable, la précision absolue est variable, le nombre de chiffres significatifs est constant
- la virgule fixe (en fait des entiers), la dynamique est fixe, la précision absolue est fixe, le nombre de chiffres significatifs dépends de la valeur
Après tu peux peut-être trouver des représentations plus exotique (par exemple partie entière et partie fractionnaire sous forme d'une fraction, fractions continues, séries convergentes) mais en gros on a fait le tour... Suivant tes besoins, tu vas t'orienter vers une représentation ou une autre, voir jongler entre plusieurs...

Voilà, c'est le troisième poste où j'ai l'impression de me répéter, tu restes enfermé dans tes convictions en y ajoutant un cynisme déplacé... Je suis là pour aider lorsque ça tombe dans mon domaine de compétence, si tu restes persuadé que je raconte des conneries et que tu as raison, je consacrerai mon temps à essayer d'aider des forumeurs un peu plus humbles.

Bonne soirée.

[Aenonis]

J'ai lu ton post hier soir.

Mais j'ai voulu d'abord dormir pour avoir la tête reposée.

J'ai beaucoup réfléchi à ce que tu m'as dit pendant que j'essayais de m'endormir et je suis arrivé à la conclusion suivante: j'ai fait ce programme il y 4-5 ans en ne connaissant rien aux représentations binaires (virgule fixe et virgule flottante) et je l'ai repris il y a une semaine. Tu as entièrement raison, je restais buté dans mon "délire" avec ma propre représentation qui ne ressemble à rien du tout si ce n'est qu'un joyeux carnaval.

Effectivement, le rapport 1/32 est gigantesque, surtout que j’implémente ça dans une liste chainée bidirectionnelle, donc, la perte mémoire est plus d'1/32 dans le cas de la représentation en base 2.

Je te remercie de m'avoir ouvert les yeux sur ma connerie...

Bien à toi,

Aenonis

[lou_ibmix_xi]

Il n'y a pas de quoi, on apprends de nos erreurs, le tout est de ne pas s'enfermer dedans...
A plus