[debutante] Conversion 8 bits en 16 bits

Bonjour

je dois écrire un algo permettant de convertir un nombre de 8 bits en 16 bits
ce sont des entier non signé

Citation:

---

Accés au 8 bits de poids faibles d'une donnée 16 bits : fonction get_poids_faible
Exemple x= get_poids_faible(0123416)
Accés au 8 bits de poids forts d'une donnée 16 bits : fonction get_poids_fort
Exemple x= get_poids_fort(0123416)
Modification 8 bits de poids faibles d'une donnée 16 bits : procédure set_poids_faible Exemple set_poids_faible(x,128)
Modification 8 bits de poids fort d'une donnée 16 bits : procédure set_poids_fort
Exemple set_poids_fort(x,0)

---

j'ai ceci comme indication mais il y a des trucs que comprends

manuellement je fais aisi pour convertir un nombre de 16 bits en 8 bits

Exemple
C2(16) en 16 bits =
1100 0010
2^31+2^30+2^25

en 8 bits
2^15+2^14+2^10

comment arriver a faire la meme chose avec un algo

a+

8O je ne comprends RIEN!! Tu peux réexpliquer??

Un nombre de 8 bits se transforme en 16 bits en.... ajoutant 8 zéros à gauche!

De + dans ton exemple
C2(16) en 16 bits =
1100 0010
2^31+2^30+2^25 ,

QU'EST-CE que c'est que ces puissances de 2 ??????

1100 0010 = 2^7+2^6+2^1...

Je deviens :fou:

en fait c'etait un exemple pour lorsque on fait une conversion
Hexadecimal -> Decimal

mais en fait mon raisonement n'etait pas bon
En fait j'aurais rajouté 16 zeros a droite , pour cela il me faut savoir quelle le bit le plus a droite
je recupere le LSB

mais je comprends pas a quoi me sert ca

Citation:

---

Modification 8 bits de poids faibles d'une donnée 16 bits : procédure set_poids_faible Exemple set_poids_faible(x,128)

---

Habituellement, je maîtrise bien le binaire, mais là, j'avoue que je n'ai rien compris à ton problème non plus...
Pourrais-tu poster le texte initial, en version intégrale, stp ?

Notamment pour savoir ce que tu dois réellement faire, et à quoi vont bien pouvoir servir tes fonctions set_??? et get_??? ...

Pour ta fonction set_poids_faible, comme le dit l'intitulé, elle remplace les 8 bits de poids faible d'un entier 16 bits par 8 autres bits quelconques.

A priori elle fait donc un truc comme ça (balise code pour avoir une chasse fixe seulement) :

Code:

---

1 2 3

set_poids_faible(43685,234) 43685 = 1010 1010 1010 0101 234 = 1110 1010

---

On annule les 8 bits de poids faible du premier argument :

Code:

---

1010 1010 0000 0000 = 43520

---

On annule ces bits par un masquage AND sur les 8 bits de poids fort :

Code:

---

1 2 3

1010 1010 1010 0101 AND 1111 1111 0000 0000 = 1010 1010 0000 0000 = 43520

---

1111111100000000 vaut, en décimal, 65280.

On fait un masque OR avec le second argument (ou une addition, dans ce cas précis SEULEMENT ça revient au même) :

Code:

---

1 2 3 4

1010 1010 0000 0000 OR 1110 1010 = ------------------- 1010 1010 1110 1010 = 43754

---

Donc, set_poids_faible(43685,234)=43754.

En hexa, ça apparaît immédiatement :

Code:

---

1 2 3 4 5

43685 = AAA5 234 = EA 43754 = AAEA ^^ ||--- Les deux derniers chiffres hexa de l'entier 16 bits ont été remplacés par ceux de l'entier 8 bits.

---

En pseudo-code, ça donne ça :

Code:

---

1 2 3 4 5 6

set_poids_faible ( entier16, entier8 ) DEBUT entier16<-entier16 AND 1111111100000000 ; entier16<-entier16 OR entier8 ; RETOUR entier16 ; FIN

---

Mais je ne vois pas en quoi ça peut t'aider, ni ce que tu dois faire à l'origine...

C'est une formule magique permettant de faire:

Code:

---

x = y | (x & 0xFF00)

---

En algo, ShootDX, pas en C... ;-)

Citation:

---

Pourrais-tu poster le texte initial, en version intégrale, stp ?

---

oui bien sur ca serra plus simple

Citation:

---

ous les langages propose un convertion de type entre les différents types d'entiers non signés. Prenons un exemple algorithmique

Variable
x : entier non signé 8 bits = 128
y : entier non signé 16 bits

Début
y = entier_16_bits_ns (x)
Fin


Variable
x : entier non signé 8 bits
y : entier non signé 16 bits = 128
dépassement : booléen
Début
entier_8_bits_ns (y,&x,&dépassement)
Fin

Fonctions disponibles

Accés au 8 bits de poids faibles d'une donnée 16 bits : fonction get_poids_faible
Exemple x= get_poids_faible(0123416)
Accés au 8 bits de poids forts d'une donnée 16 bits : fonction get_poids_fort
Exemple x= get_poids_fort(0123416)
Modification 8 bits de poids faibles d'une donnée 16 bits : procédure set_poids_faible Exemple set_poids_faible(x,128)
Modification 8 bits de poids fort d'une donnée 16 bits : procédure set_poids_fort
Exemple set_poids_fort(x,0)

1. Ecrire l'algorithme de la fonction de convertion d'un entier 8 bits non signé en un entier 16 bits non signé.
Fonction entier_16_bits_ns (entier non signé 8 bits x) : entier non signé 16 bits

---

ton explication sur cette fonction ("set_poids_faible") ma permis de comprendre quelle ne me servait pas dans mon cas

Salut,

a moins de craquer completement, ceci n est il pas correct ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Variables: x : entier non signé 8 bits = 128 y : entier non signé 16 bits   entier_16_bits_ns (entier non signé 8 bits x): retourne entier non signé 16 bits Debut Variable: y : entier non signé 16 bits   y = 0 set_poids_faible(y, x) set_poids_fort(y, 0) retourne y Fin

---

++
Pouic

Citation:

---

Envoyé par bolo

1. Ecrire l'algorithme de la fonction de convertion d'un entier 8 bits non signé en un entier 16 bits non signé.

---

Le problème est nettement plus simple que ce que laissait suggérer le message initial :wink:.

Citation:

---

ton explication sur cette fonction ("set_poids_faible") ma permis de comprendre quelle ne me servait pas dans mon cas

---

Bien au contraire c'est la base même de la solution.
La solution proposée par Pouic me semble tout à fait correcte, à ceci près que l'appel à "set_poids_fort" est inutile si on initialise y à 0 :wink:.

Citation:

---

Envoyé par Franckintosh

<....> à ceci près que l'appel à "set_poids_fort" est inutile si on initialise y à 0 :wink:.

---

la facheuse manie de tout intialiser en C ..... :D
=> je pense qu il ne faut pas faire cette initialisation, et juste utiliser les deux fonctions disponibles....

++
Pouic

Citation:

---

Envoyé par Pouic

la facheuse manie de tout intialiser en C ..... :D
=> je pense qu il ne faut pas faire cette initialisation, et juste utiliser les deux fonctions disponibles....

---

Personnellement je préfère initialiser puis n'utiliser que "set_poids_faible", c'est selon moi plus rapide (même si que légèrement) d'initialiser que d'appeler une fonction de changements conditionnels de bits... mais ça c'est aussi une manie de codeur :wink:.

Citation:

---

Envoyé par Franckintosh

Citation:

---

Envoyé par Pouic

la facheuse manie de tout intialiser en C ..... :D
=> je pense qu il ne faut pas faire cette initialisation, et juste utiliser les deux fonctions disponibles....

---

Personnellement je préfère initialiser puis n'utiliser que "set_poids_faible", c'est selon moi plus rapide (même si que légèrement) d'initialiser que d'appeler une fonction de changements conditionnels de bits... mais ça c'est aussi une manie de codeur :wink:.

---

je suis d accord.... mais d apres l enonce, on n a droit qu a ces fonctions..
donc cela sous entend que l on ne peut pas directement initialiser une variable 16bits... (j me trompe peut etre, mais bon...)

++
Pouic

Citation:

---

Envoyé par Pouic

je suis d accord.... mais d apres l enonce, on n a droit qu a ces fonctions..
donc cela sous entend que l on ne peut pas directement initialiser une variable 16bits...

---

Ce n'est pas du tout explicite dans l'énoncé mais c'est un point qu'il peut être intéressant à savoir pour la justesse de l'algo. Dans tous les cas il y a une solution donc je pense que notre camarade bolo peut présenter quelque chose de correct maintenant :D.

Franckintosh :arrow: Je soutiens Pouic sans restrictions, sur ce coup.
Pas d'initialisation manuelle, tu n'as à priori pas les primitives pour effectuer ça à ta disposition. :-D
Et c'est parfaitement explicite, au contraire : tout ce qui n'est pas explicitement autorisé est inexistant, pour ne pas dire interdit.

La rapidité n'est même pas à prendre en compte dans ce cas précis, non plus que les habitudes d'un langage donné : c'est de l'algo. C'est fait pour comprendre le principe, pas forcément pour l'implémenter réellement.

Donc, le premier code de Pouic est celui qu'il faut, j'aurais même tendance à dire le seul possible au vu de l'énoncé.

Citation:

---

Envoyé par Pouic

Salut,

a moins de craquer completement, ceci n est il pas correct ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Variables: x : entier non signé 8 bits = 128 y : entier non signé 16 bits   entier_16_bits_ns (entier non signé 8 bits x): retourne entier non signé 16 bits Debut Variable: y : entier non signé 16 bits   y = 0 set_poids_faible(y, x) set_poids_fort(y, 0) retourne y Fin

---

++
Pouic

---

je suis vraiment bete c'etait en fait super simple merci bc :oops:

pour des entier signés si jeux convertir en 8 bits en 1- bits je fais la meme chose ?

Citation:

---

Envoyé par bolo

pour des entier signés si jeux convertir en 8 bits en 1- bits je fais la meme chose ?

---

non, il faut tester le bit de poids fort de l entier 8 bits:
si c est 1 (donc il est negatif) => mettre des 1 sur 8 bits a gauche (extension du signe)
si c est 0 => meme chose que non signé

++
Pouic

Citation:

---

si c est 1 (donc il est negatif) => mettre des 1 sur 8 bits a gauche (extension du signe)
si c est 0 => meme chose que non signé

---

oui j'ai compris avec cette fonction get_poids_faible(0123416)
avec cette fonction je récupère les 8 bits à gauche
mais pour récupérer le dernier bit a gauche il faut tester si ce nombre est négatif ?

Citation:

---

Envoyé par bolo

oui j'ai compris avec cette fonction get_poids_faible(0123416)
avec cette fonction je récupère les 8 bits à gauche
mais pour récupérer le dernier bit a gauche il faut tester si ce nombre est négatif ?

---

Non, ce sont les 8 bits à droite que tu récupères : le poids faible est à droite lorsqu'on écrit l'entier en binaire.

Et le bit de signe pour un entier N bits, c'est le Nème bit en partant du LSB ou le 1er bit en partant du MSB, à toi de voir ce que tu retiens le mieux.

En pratique, il te faudrait une fonction get_bit_poids_fort(entier8) pour le faire "proprement". Cependant, on peut utiliser aussi des comparaisons signées et non-signées pour faire ça.
Ceci devrait marcher :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

Variables: x : entier signé 8 bits y : entier signé 16 bits   entier_16_bits_s (entier signé 8 bits x): retourne entier signé 16 bits Debut Variable: y : entier signé 16 bits   set_poids_faible(y, x) # Choisir UNE SEULE des trois lignes suivantes. si x>127 alors #comparaison non-signée. si x<0 alors #comparaison signée. si get_bit_poids_fort(x)=1 #extraction du bit # Suite de l'algo set_poids_fort(y, 255) sinon set_poids_fort(y, 0) finsi retourne y Fin

---

[EDIT]
On peut aussi faire vicieux, et n'utiliser que les primitives d'origine, en fait :

Code:

---

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

Variables: x : entier signé 8 bits y : entier signé 16 bits   entier_16_bits_s (entier signé 8 bits x): retourne entier signé 16 bits Debut Variable: y : entier signé 16 bits   #on met x en poids fort, pas en poids faible (inversion). set_poids_fort(y, x) #on met le poids faible à zéro pour être propre. set_poids_faible(y, 0) si y<0 alors #Si y<0, alors son MSB vaut 1. Ce MSB est aussi celui de x, donc x<0 !!! #On étend le signe en mettant 255 dans le poids fort (=8 bits à 1). set_poids_fort(y, 255) sinon #Si y>=0, alors son MSB vaut 0 et x>=0 #Il n'y a pas de bit de signe, on met tout le poids fort à zéro. set_poids_fort(y, 0) finsi #Dans tous les cas, il faut maintenant mettre x en poids faible. set_poids_faible(y, x) retourne y Fin

---

:king:
[/EDIT]

Citation:

---

Non, ce sont les 8 bits à droite que tu récupères : le poids faible est à droite lorsqu'on écrit l'entier en binaire.

---

Je me suis trompée je voulais dire a droite :(
En fait le signe c'est le dernier bit le plus a droite et le bit du signe c'est le dernier le plus a droite

Code:

---

set_poids_faible(y, x)

---

pour faire ca il ne faut pas que les deux varaibles soit de 8 bits ?

Code:

---

si x<0 alors #comparaison signée.

---

la je comprends on verifie si le nombre négatif

Code:

---

si get_bit_poids_fort(x)=1 #extraction du bit

---

get_poids_fort permet d'acceder au 4 bits les plus a gauche car le nombre est sur 8 bits
c'est bien ca apres j'ai compris :)