Discussion :

[AsmCode]

Supposons que j'ai 2 octets: A et B

leur code binaire est: 01000001 et 01000010

ce qui donne la valeur binaire: 16706 ce que je fais c'est 65*256+66 mais si j'ai beaucoup plus de octets dont je voudrais la valeur est-ce qu'il y aurait une façon plus simple pour le calculer ?

Aussi je voudrais faire l'inverse, prendre 16706 et renvoyer 01000001 et 01000010

Mais quelle serait la façon la plus simple de calculer cela ?

Comment faire en sorte aussi de n'en prendre qu'une portion de 16706 pour que ça me renvoit le premier octet, puis l'autre portion pour me renvoyer le 2e ? Admettons que je ne veuille pas convertir ma valeur 16706 d'un seul coup

Merci

[Laurent Gomila]

En standard il y a std::bitset (inclure <bitset>) qui permet de faire les conversions binaire <-> décimal et de manipuler les bits.

[2Eurocents]

Il y a aussi toutes les opérations de masquage et/ou de décalage.

Soit A une valeur sur n octets.

L'octet le moins significatif B peut être obtenu par : B = A && 255
Opération dans laquelle le && est un opérateur ET bit à bit.

L'octet qui suit, C, est obtenu par : C = (A && (255 << 8 )) >> 8
Opération dans laquelle les opérateurs << n et >> n sont des décalages de n bits dans la direction des flèches.

L'octet de poids encore supérieur, D : D = (A && (255 << 16)) >> 16

etc.


Quand à la recomposition, elle peut se faire avec les mêmes opérateurs, plutôt qu'avec les opérateurs arithmétiques :
A = B + (C << 8 ) + (D << 16) + ...

[alveric]

Loulou24 < J'ai pas trop compris ta reponse... Le topic a ete deplace depuis le forum C++ ?

Comment faire en sorte aussi de n'en prendre qu'une portion de 16706 pour que ça me renvoit le premier octet, puis l'autre portion pour me renvoyer le 2e ?

Soit tu restes en manipulation d'entiers, alors le k-eme octet de N s'obtient par

Code :

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

(N / (256 ^ (k-1)) mod 256

En binaire, ca devient:

Code :

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

(N >> (8*(k-1))) ET 255

ou A >> B decale A de B bits vers la droite (i.e. divise par 2^B).

[AsmCode]

Merci, mais je n'ai rien compris avec les opérateurs

En fait je voudrais une méthode simple pour ne pas que ça soit trop lour en mémoire si admettons je dois convertir une suite de 10 octets, admettons ADCDEFGHIJ ce qui devrait me donner une valeur sur 80 bits

Mais je parlais de faire l'inverse avec ce nombre mais sans loader les 80 bits en mémoire, car si je travailles avec 10 mb, ça fait 80 millions bits en mémoire

C'est pour cela je voulais une méthode qui permet d'en prendre une partie à la fois et la je ferais une boucle.

[Laurent Gomila]

Oups, je pensais vraiment pas qu'on était sur le forum Algorithmes. Vous pouvez zapper ma réponse

[AsmCode]

Loulou24 < J'ai pas trop compris ta reponse... Le topic a ete deplace depuis le forum C++ ?

Comment faire en sorte aussi de n'en prendre qu'une portion de 16706 pour que ça me renvoit le premier octet, puis l'autre portion pour me renvoyer le 2e ?

Soit tu restes en manipulation d'entiers, alors le k-eme octet de N s'obtient par

Code :

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

(N / (256 ^ (k-1)) mod 256

En binaire, ca devient:

Code :

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

(N >> (8*(k-1))) ET 255

ou A >> B decale A de B bits vers la droite (i.e. divise par 2^B).

J'ai essayé:

(16706 / (256 ^ 0)) mod 256 = 65

mais (16706 / (256 ^ 1)) mod 256 != 66 ça donne 65,2578125

:o

[alveric]

Merci, mais je n'ai rien compris avec les opérateurs

Les operateurs >> et << (notation habituelle, certains langages n'nt peut-etre pas la meme notation) permettent de modifier une valeur entiere, en agissant sur les bits de sa representation en binaire.
Ex: 13 en decimal s'ecrit 8+4+1 = 1101 en dinaire
13 >> 3 = 1101 decale de trois bits vers la droite = 1
13 << 1 = 1101 decale de un bit vers la gauceh = 11010
Mais avec ce s manipulations, il faut faire attention a ne pas faire de debordement (si un entier est code sur 16 bits, le resultat de 1 << 16 depend du langage / la machine), et au cas des valeurs signees (par ce qu'un bit est reserve pour coder le signe).

Mais je parlais de faire l'inverse avec ce nombre mais sans loader les 80 bits en mémoire, car si je travailles avec 10 mb, ça fait 80 millions bits en mémoire

C'est un autre probleme... Tes valeurs viennent d'ou (fichier, reseau...) ?

[alveric]

mais (16706 / (256 ^ 1)) mod 256 != 66 ça donne 65,2578125

Division entiere... La syntaxe depend du langage. Tu bosses avec quoi ?

[AsmCode]

mais (16706 / (256 ^ 1)) mod 256 != 66 ça donne 65,2578125

Division entiere... La syntaxe depend du langage. Tu bosses avec quoi ?

J'ai essayé avec la calculatrice de windows

[AsmCode]

Donc pour reconstruire ma suite d'octet je dois faire:

for C = 1 to Nombre_octets

N / (256 ^ C-1)) mod 256

en arrondissant l'entier s'il y a un reste, ça va me donner tout mes octets ?

[AsmCode]

Mais si j'ai une valeur N qui est très grande, admettons que j'ai 16 octets ce qui veut dire que j'aurais une valeur N de 3,4028236692093846346337460743177e+38

en supposant que tout mes 16 octets sont de bit 1 dans ce cas-ci.

Avec cette valeur c'est lourd à traiter, est-ce qu'il y aurait moyen de diviser ce nombre en plusieurs morceaux, pour ensuite aditionner les résultats ??

[alveric]

en arrondissant l'entier s'il y a un reste, ça va me donner tout mes octets ?

Il n'y a pas d'arrondi a faire, vu qu'il n'y a pas de reste (division entiere). La formule decoupe exactement le nombre en octets, y a pas de bout qui depasse .

Avec cette valeur c'est lourd à traiter, est-ce qu'il y aurait moyen de diviser ce nombre en plusieurs morceaux, pour ensuite aditionner les résultats ??

La formule que je t'ai donnee extrait un octet donne d'un nombre entier, c'est bien ce que tu m'as demande, non ?
Pour additionner les octets afin de retrouver la valeur complete, bah tu dois pouvoir y arriver, non ?

Si tu expliquais le contexte de ton travail, on pourrait mieux t'aider. Tu as l'air d'etre limite en memoire, par rapport a des nombres de taille enorme (80 Mo ? ). Qu'est-ce que tu veux faire exactement ?

[AsmCode]

Et bien je cherches une façon de représenter des octets avec leur valeur numérique, mais je ne suis pas limité en mémoire, je cherches juste la façon la plus optimale

La fomule que tu m'as donné fait exactement ce dont j'ai besoin, mais je me demandais s'il n'y avait pas une façon de modifier la formule afin de prendre une "partie" du nombre pour aller chercher 1 octet ?

Ça éviterait d'encombrer la mémoire d'un chiffre de fou comme: 3,4028236692093846346337460743177e+38

Parce que même en C, est-ce que le cpu ne vas pas avoir de la misère à effectuer des opérations sur ce nombre avec la formule que tu m'as donné ?

Jusqu'à quel grosseur de nombre je peux avoir avant que le cpu ait de la misère ?

[2Eurocents]

Si tu veux travailler avec des opérateurs arithmétiques (divisions, etc.), selon ton compilateur, tu seras bloqué sur des nombres exprimés sur 32 ou 64 bits, le plus souvent.

Moyennant l'usage de bibliothèques du genre BigNum, tu pourras faire voler en éclats cette limitation.

Et si tu travailles uniquement avec des opérateurs de masquage/décalage, tu n'as plus à gérer la signification numérique du nombre et tu ne travailles que sur des paquets d'octets/de bits dont tu fait tout ce que tu veux ... Mais c'est parfois plus difficile à se représenter.

Bon courage

[alveric]

Je ne comprends pas trop ou tu veux en venir... Si tu veux travailler ser des grands nombres de maniere efficace, il y a des bibliotheques faites pour ca, on en a parle il y pas longtemps par ici.
Mais de toute maniere, si tu veux faire des calculs avec ces nombres, il faut bien qu'ils soient en memoire sous une forme ou une autre, non ? Si tes nombres sont de l'ordre de 2^1024, bah tu auras toujours besoin d'au minimum 1024 bits pour les coder, que ce soit d'un bloc ou par bouts de 8.
Un autre probleme que tu vas rencontrer avec d'aussi grands nombres, c'est qu'ils ne tiennent pas dans les registres Donc tu es rellement oblige de les tronconner toi-meme ou de le faire faire par une bibliotheque de calcul de grands nombres...

[AsmCode]

Si tu veux travailler avec des opérateurs arithmétiques (divisions, etc.), selon ton compilateur, tu seras bloqué sur des nombres exprimés sur 32 ou 64 bits, le plus souvent.

Moyennant l'usage de bibliothèques du genre BigNum, tu pourras faire voler en éclats cette limitation.

Et si tu travailles uniquement avec des opérateurs de masquage/décalage, tu n'as plus à gérer la signification numérique du nombre et tu ne travailles que sur des paquets d'octets/de bits dont tu fait tout ce que tu veux ... Mais c'est parfois plus difficile à se représenter.

Bon courage

Donc si j'ai bien compris avec le masquage/décalage, je pourrais facilement transformer ma valeur numérique très longue genre 128 ou 1024 bits par exemple sans perdre de performance ni emcombrer la mémoire ?

Peux-tu me donner un exemple, car j'ai de la misère à visualiser

Merci.

[2Eurocents]

Et si tu travailles uniquement avec des opérateurs de masquage/décalage, tu n'as plus à gérer la signification numérique du nombre et tu ne travailles que sur des paquets d'octets/de bits dont tu fait tout ce que tu veux ... Mais c'est parfois plus difficile à se représenter.

Bon courage

Donc si j'ai bien compris avec le masquage/décalage, je pourrais facilement transformer ma valeur numérique très longue genre 128 ou 1024 bits par exemple sans perdre de performance ni emcombrer la mémoire ?

Peux-tu me donner un exemple, car j'ai de la misère à visualiser

Merci.

Justement, je disais que c'est difficile à se représenter car on ne travaille plus que sur des tranches du grand nombre ... il n'y a plus que des tas de bits et d'octets, découpés arbitrairement pour les nécessités du traitement.

La représentation du grand nombre n'existe plus ... il n'y a plus que ses octets successifs ...

Ton nombre sur 1024 bits sera traité comme 128 octets, libre à toi de n'en conserver que des bouts en mémoire.

La valeur numérique de l'ensemble devient inaccessible.

Et pour des opérations numériques entre deux nombres de cette nature, il te faut revoir à la base l'algorithme des opérations - la multiplication doit pouvoir se faire avec des factorisations partielles, par exemple.

[AsmCode]

Je ne comprends pas trop ou tu veux en venir... Si tu veux travailler ser des grands nombres de maniere efficace, il y a des bibliotheques faites pour ca, on en a parle il y pas longtemps par ici.
Mais de toute maniere, si tu veux faire des calculs avec ces nombres, il faut bien qu'ils soient en memoire sous une forme ou une autre, non ? Si tes nombres sont de l'ordre de 2^1024, bah tu auras toujours besoin d'au minimum 1024 bits pour les coder, que ce soit d'un bloc ou par bouts de 8.
Un autre probleme que tu vas rencontrer avec d'aussi grands nombres, c'est qu'ils ne tiennent pas dans les registres Donc tu es rellement oblige de les tronconner toi-meme ou de le faire faire par une bibliotheque de calcul de grands nombres...

C'est sûr que je dois loader le nombre en mémoire pour travailler dessus, mais je pensais plus à une méthode du genre, admettons j'ai le nombre 16076

Au lieu de loader en mémoire les bits de sa valeur. Ce nombre est stocké dans un fichier, alors je pourrais aller lire une partie de ce nombre, le traiter puis avoir un octet et tant qu'il reste une partie du nombre, je modifie mon octets ou mes octets obtenue, donc j'encombre moins la mémoire, mais je fais plus d'accès au disque. Mais ceci est un petit nombre. Je me disais que si j'ai un nombre comme 1 millions, je pourrais stocker cela en mémoire sous un notation scientifique, prendre une partie du nombre et le traiter puis faire une boucle, mais je ne vois pas comment

[AsmCode]

Et si tu travailles uniquement avec des opérateurs de masquage/décalage, tu n'as plus à gérer la signification numérique du nombre et tu ne travailles que sur des paquets d'octets/de bits dont tu fait tout ce que tu veux ... Mais c'est parfois plus difficile à se représenter.

Bon courage

Donc si j'ai bien compris avec le masquage/décalage, je pourrais facilement transformer ma valeur numérique très longue genre 128 ou 1024 bits par exemple sans perdre de performance ni emcombrer la mémoire ?

Peux-tu me donner un exemple, car j'ai de la misère à visualiser

Merci.

Justement, je disais que c'est difficile à se représenter car on ne travaille plus que sur des tranches du grand nombre ... il n'y a plus que des tas de bits et d'octets, découpés arbitrairement pour les nécessités du traitement.

La représentation du grand nombre n'existe plus ... il n'y a plus que ses octets successifs ...

Ton nombre sur 1024 bits sera traité comme 128 octets, libre à toi de n'en conserver que des bouts en mémoire.

La valeur numérique de l'ensemble devient inaccessible.

Et pour des opérations numériques entre deux nombres de cette nature, il te faut revoir à la base l'algorithme des opérations - la multiplication doit pouvoir se faire avec des factorisations partielles, par exemple.

Mais c'est justement cette méthode que je cherches

Comment par exemple, admettons que j'ai mes 2 octets de tantôt, soit AB
donc valeur numérique de 16706, petit nombre pour faire l'exemple plus simple, comment "découper" ce nombre en tranche pour le traiter plus facilement au final ? :o