Discussion :

[bolo]

Bonjour

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

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+

[Nemerle]

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

[bolo]

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

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

[Mac LAK]

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 :

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

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 :

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

1010 1010 0000 0000 = 43520

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

Code :

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

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 :

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

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 :

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

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 :

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

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

[ShootDX]

C'est une formule magique permettant de faire:

Code :

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

x = y | (x & 0xFF00)

[Mac LAK]

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

[bolo]

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

oui bien sur ca serra plus simple

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

[Pouic]

Salut,

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

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

[Franckintosh]

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 .

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 .

[Pouic]

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

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

++
Pouic

[Franckintosh]

la facheuse manie de tout intialiser en C .....
=> 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 .

[Pouic]

la facheuse manie de tout intialiser en C .....
=> 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 .

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

[Franckintosh]

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 .

[Mac LAK]

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

[bolo]

Salut,

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

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

[bolo]

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

[Pouic]

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

[bolo]

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 ?

[Mac LAK]

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 :

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

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

[/EDIT]

[bolo]

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 :

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

set_poids_faible(y, x)

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

Code :

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

 si x<0 alors                 #comparaison signée.

la je comprends on verifie si le nombre négatif

Code :

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

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