Décomposer une valeur pour en retirer les octets ?

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 :wink:

Merci :D

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

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) + ...

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

Citation:

---

Envoyé par AsmCode

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:

---

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

---

En binaire, ca devient:

Code:

---

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

---

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

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

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 :wink:

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

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

Citation:

---

Envoyé par alveric

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

Citation:

---

Envoyé par AsmCode

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:

---

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

---

En binaire, ca devient:

Code:

---

(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

Citation:

---

Envoyé par AsmCode

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

---

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).

Citation:

---

Envoyé par AsmCode

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 :wink:

---

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

Citation:

---

Envoyé par AsmCode

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

---

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

Citation:

---

Envoyé par alveric

Citation:

---

Envoyé par 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 :lol:

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 ? :D

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 ??

Citation:

---

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 ;).

Citation:

---

Envoyé par AsmCode

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 ? 8O ). Qu'est-ce que tu veux faire exactement ?

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 :D

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é ? :wink:

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

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

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...

Citation:

---

Envoyé par 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

---

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 :wink:

Merci. :D

Citation:

---

Envoyé par AsmCode

Citation:

---

Envoyé par 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 :wink:

Merci. :D

---

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.

Citation:

---

Envoyé par 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...

---

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 :wink:

Citation:

---

Envoyé par 2Eurocents

Citation:

---

Envoyé par AsmCode

Citation:

---

Envoyé par 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 :wink:

Merci. :D

---

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 :D

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

Citation:

---

Envoyé par AsmCode

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.

---

Si tes nombres font des megaoctets, alors tu peux penser a les sectionner pour ne pas les avoir en memoire en entier, mais la le disque va te ralentir tres fortement (surtout que tu vas rogner sur le cache), pense plutot a booster la RAM... Et il faut avoir des algos qui permettent de faire ca !

A moins d'avoir une memoire tres limitee (et inaugmentable) et des nombres tres grands (la notion de "grand" depend de la memoire disponible), cette solution n'est pas a choisir... Non seulement ca va compliquer le code, mais surtout ca va ralentir tres fortement ton programme. Apres, c'est un compromis temps/memoire, a toi de savoir ce qui est acceptable.

Citation:

---

Envoyé par AsmCode

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

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

---

Le plus facilement, c'est par octet. Le plus efficace, ca depend des calculs que tu veux faire dessus, mais la taille du registre de la machine devrait etre une bonne indication (qui est le plus souvent un multiple de l'octet, d'ailleurs).

Citation:

---

Envoyé par alveric

Citation:

---

Envoyé par AsmCode

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.

---

Si tes nombres font des megaoctets, alors tu peux penser a les sectionner pour ne pas les avoir en memoire en entier, mais la le disque va te ralentir tres fortement (surtout que tu vas rogner sur le cache), pense plutot a booster la RAM... Et il faut avoir des algos qui permettent de faire ca !

A moins d'avoir une memoire tres limitee (et inaugmentable) et des nombres tres grands (la notion de "grand" depend de la memoire disponible), cette solution n'est pas a choisir... Non seulement ca va compliquer le code, mais surtout ca va ralentir tres fortement ton programme. Apres, c'est un compromis temps/memoire, a toi de savoir ce qui est acceptable.

---

En fait ce que j'avais idée de faire c'est que mon nombre est textuellement représenté dans une notation scientifique ou mathématique pour qu'il soit court. Puis je voulais le charger en mémoire. Admettons charger 2^128. Ensuite je voudrais prendre une portion de cette valeur puis la traiter, ensuite prendre une autre portion, puis la traiter. Mais suis-je obligé d'avoir la valeur entière du nombre pour le découper en morceau pour le traiter ou si il y a des algos pour faire un peu comme j'ai dit ? :D

Citation:

---

Envoyé par AsmCode

Ensuite je voudrais prendre une portion de cette valeur puis la traiter, ensuite prendre une autre portion, puis la traiter. Mais suis-je obligé d'avoir la valeur entière du nombre pour le découper en morceau pour le traiter ou si il y a des algos pour faire un peu comme j'ai dit ? :D

---

S'il est enregistre dans un fichier sous forme binaire (i.e. pas un fichier texte qui contient la suite des chiffres), tu peux lire simplement octet par octet... (suiant le langage, bien sur) Si tu as besoin, tu peux rajouter au debut du fichier un en-tete qui donne la taille du nombre en octets, par exemple (encore que la taille du fichier soit accessible directement par le langage le plus souvent).

Citation:

---

Envoyé par alveric

Citation:

---

Envoyé par AsmCode

Ensuite je voudrais prendre une portion de cette valeur puis la traiter, ensuite prendre une autre portion, puis la traiter. Mais suis-je obligé d'avoir la valeur entière du nombre pour le découper en morceau pour le traiter ou si il y a des algos pour faire un peu comme j'ai dit ? :D

---

S'il est enregistre dans un fichier sous forme binaire (i.e. pas un fichier texte qui contient la suite des chiffres), tu peux lire simplement octet par octet... (suiant le langage, bien sur) Si tu as besoin, tu peux rajouter au debut du fichier un en-tete qui donne la taille du nombre en octets, par exemple (encore que la taille du fichier soit accessible directement par le langage le plus souvent).

---

Mais dans ce cas-ci ça revient à stocker le fichier en lui-même non ? Car que je stock AB dans un fichier ou bien 16706 binaire, c'est la même chose :D

Bah oui ? Tu voudrais faire comment ?

...oups... pas bien lu:

Citation:

---

En fait ce que j'avais idée de faire c'est que mon nombre est textuellement représenté dans une notation scientifique ou mathématique pour qu'il soit court.

---

Donc tu voudrais enregistrer la chaine "2^128" ou "1.123E456" par exemple ?

Citation:

---

Envoyé par alveric

Bah oui ? Tu voudrais faire comment ?

...oups... pas bien lu:

Citation:

---

En fait ce que j'avais idée de faire c'est que mon nombre est textuellement représenté dans une notation scientifique ou mathématique pour qu'il soit court.

---

Donc tu voudrais enregistrer la chaine "2^128" ou "1.123E456" par exemple ?

---

Oui :)

Et à partir de là, je lis mon fichier, je lis admettons "2^128" donc je sais que tout mes octets sont en fait de la valeur de 2^128 alors j'aimerais diviser cette opération en plusieurs partie pour ne pas demander au processeur de calculer d'un seul coup 2^128 pour ne pas mettre tout mes octets en mémoire d'un seul coup non plus. Mais plutôt de procéder d'une façon par "morceau" donc 1 ou plusieurs octets à la fois, puis dans une boucle je passes "aux prochaines octets" selon les morceaux de ma valeur numérique qui reste.

Quelque chose du genre je prends 2^1 de mon 2^128, il me reste donc 2^127 à traiter ou un truc du genre. :wink:

Ok, mais sous quel format tu penses enregistrer tout ca ? (2^128-5), par exemple, tu l'enregistrerais comment ? ou 3^15 ? ou un mechant nombre premier d'un millier de bits ?

euh.. ou trouves-tu le 2^128-5 :?:

J'ai de la misère à te suivre la dessus :wink:

Je vouslais dire: quel format tu veux pour ton texte ? Si tu veux enregistrer le nombre ((2^128)-5) par exemple, tu le codes comment dans ton fichier ? autre exmeple, pour 3^15 tu fais comment ?

Hmm, j'avais pensé à un format selon la valeur à traiter. C'est-à dire utiliser un certain standard de notation court qui me permet en même temps de le diviser aisément par portion.

Par exemple la valeur 16706 pour 'AB' pourrait se noter:

(2^14) + 322

Mais je dois encore trouver comment traiter une partie de cette notation afin de me faire une boucle pour ne sortir qu'un petit nombre d'octets à la fois. Bien sûr que cette partie ne sortirait pas la vrai valeur du premier octet par exemple, mais je peux toujours additionner les résultat des calculs à chaque itération de la boucle. C'est plus de calcul, mais au moins je n'encombre pas la mémoire avec un gros paquet de bits, c'est juste une énorme boucle. :wink:

Mais je dois quand même trouver comment traiter cela par partie, ça doit sûrement se faire, c'est seulement des maths :D

Quelqu'un à une idée ? :wink:

Admettons on prend l'exemple simple de (2^14) + 322

Comment traiter cela par partie :?:

Dans ce cas, autant faire/reprendre un calculateur symbolique, non ?

euh qu'est-ce qu'un calculateur symbolique ? :D

... Un calculateur capable de calculer à partir de la représentation symbolique (la suite de chiffre représentant un nombre), plutôt qu'à partir de la représentation numérique (la suite de bits en mémoire, agencée de manière conventionnelle pour le calculateur).

De toutes façons, depuis le début, on tourne autour du problème du nombre (la valeur) et de sa représentation, qui sont deux choses différentes.

Et bien la représentation j'ai une bonne idée comment la faire, il faut juste que je me monte un algo qui va pouvoir me "monter" mon symbole. Mais ça me prend aussi un algo qui va pouvoir me "démonter" ce symbole en morceau pour pouvoir aller rechercher mes octets. Mais c'est là que je ne sais pas vraiment comment je pourrais m'y prendre.

Est-ce qu'il y aurait une formule de mathématique qui permettrait par exemple de diviser 16706 en 3 parties par exemple et qui permettrait d'aller chercher le premier octet, admettons octet x de la partie 1, puis en examinant la 2e partie j'obtiendrai un octet y, puis ensuite un octet z

ensuite à la fin de ma boucle pour avoir mon premier octet de départ je n'aurais qu'à (aditionner ?) x+y+z pour avoir mon 65 'A' ?

Si il y aurait une façon de faire de ce genre ce serait parfait. :D