Discussion :

[bolo]

Bonjour

j'aimerais creer un algo me permetant de modifier 2 bits sur 4
par exemple j'ai ce nombre
0110
j'aimaire qui devienne ca
0011

dc je dois faire un and
var = 0110 AND 1011
et ou
var2 = var OR 0001

donc ma procédure

Code :

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

1
2
3
4
5
6
Procedure sett (*x : 4 bit , e : 4 bits)
Variable 
masque : 4 bit
Debut
 
Fin

je me demande comment arriver a calculer le masque


merci

[sovitec]

Salut,

Il y a des tas de façons de modifier 2 bits sur 4. Mais celles que tu donnes ne modifient pas forcément 2 bits sur 4. Une méthode qui modifierait toujours 2 bits sur 4 et qui donnerait le résultat décrit est :

Code :

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

result = (var AND 1010) OR ((NOT var) and 0101)

Je pense qu'il faut que tu sois plus précis(e) dans ce que tu veux faire.

[bolo]

Salut,

Il y a des tas de façons de modifier 2 bits sur 4. Mais celles que tu donnes ne modifient pas forcément 2 bits sur 4. Une méthode qui modifierait toujours 2 bits sur 4 et qui donnerait le résultat décrit est :

Code :

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

result = (var AND 1010) OR ((NOT var) and 0101)

Je pense qu'il faut que tu sois plus précis(e) dans ce que tu veux faire.

en fait j'utilise or et and pour voire mettre des bits soit 1 soit 0
je ne peux utiliser NOT AND
seulement or et and

[Steki-kun]

pourquoi tu ne peux pas utiliser autre chose que OR et AND ?
sauf erreur, {OR, AND} ne forme pas un système complet donc tu ne peux pas tout faire avec (pas de NOT par exemple parce que x OR x et x AND x ca fait x), alors c'est curieux comme contrainte ...

[khayyam90]

si jamais tu as le XOR sous la main, une possibilité pour modifier le deuxième et le quatrième bits et tout simplement de faire

var XOR masque
0110 XOR 0101 ce qui donne bien 0011

[SKZ81]

J'allais le dire, de plus
var XOR result = masque (la question initiale était de calculer le masque).

De plus,
a XOR b = (a OR b) AND NOT(a AND b)
Mais si tu n'a pas NAND, t'es coincée

[Steki-kun]

Mais si tu n'a pas NAND, t'es coincée

cest clair, c'est rapé, avec or et and, on peut faire que or, and, et identité...

[Mac LAK]

Du calme, c'est pas l'opération NAND qui est requise, c'est la négation binaire (complément à un), nuance... Et encore, si c'est juste pour annuler des bits, un "AND 0" fera le résultat attendu.

Quant au XOR, il n'est bien sûr jamais "nécessaire" lorsque tu as le NOT, le OR et le AND comme l'as précisé SKZ81. Il est seulement pratique, pas plus.

bolo : Il faudrait effectivement que tu sois plus précise. Comme la dernière fois, redonnes l'énoncé complet stp, ce sera certainement plus simple.
Sinon, pour positionner et annuler des bits en même temps, il te faut impérativement deux masques :
- Un masque d'annulation de bits, appliqué avec un AND.
- Un masque de positionnement de bits, appliqué avec un OR.

Mis à part si le résultat final est toujours connu d'avance (cas rare, dans ce cas un XOR peut être utilisé), tu ne peux pas couper au fait de prendre deux masques.

[SKZ81]

je ne peux utiliser NOT AND
seulement or et and

Je ne réagissais qu'à cette partie du post.
A partir de là, parler de NOT ou de NAND me parraissait équivalent...

Mais t'as raison Mak, y'a pas de lézard...
(oui j'utilise un diminutif, on est intime maintenant )

[edit](Je craque vraiment là, en fait....) [/edit]

[edit suite au mpost suivant]Mac, oui, dzol
Par contre ou a tu vu des parenthèses [/edit]

[Mac LAK]

Je ne réagissais qu'à cette partie du post.
A partir de là, parler de NOT ou de NAND me parraissait équivalent...

Disons surtout que le NAND, au sens électronique, c'est pas la même chose : c'est "NOT (a AND b)", ce qui complexifierai pas mal les formules.

Mais t'as raison Mak, y'a pas de lézard...
(oui j'utilise un diminutif, on est intime maintenant )

Le bisou seulement si les parenthèses dans "habitué(e)" au dessus de ton avatar sont superflues...
Pour le diminutif, c'est "Lak" en général, parfois "Mac" !

[SKZ81]

En fait "Mac" ou "Lak", j'hésite encore, d'où la compression en "Mak", qui synthétise bien les deux non ? Si tu n'y voit aucune offense, je crois que je vais le garder en tant que marK personelle...

Et n'y voit rien d'ostentatoire ou de répréhensible pour un ch'tit bisous (en tout respect) sous le guy de la bonne année...
Tu crains l'hépatite ou quoi ???

[edit]
par contre ma [edit=future]copine[/edit] risque p'têt d'être jalouse...
je lui poserai pas la question !
[/edit

[bolo]

bolo : Il faudrait effectivement que tu sois plus précise. Comme la dernière fois, redonnes l'énoncé complet stp, ce sera certainement plus simple.
Sinon, pour positionner et annuler des bits en même temps, il te faut impérativement deux masques :
- Un masque d'annulation de bits, appliqué avec un AND.
- Un masque de positionnement de bits, appliqué avec un OR.

je vais essayer d'etre plus précise
j'ai un exo voila la consigne

Nous allons décrire les algorithmes permettant de lire et modifier l'exposant et la mantisse d'un réel FSP.
Fonctions et procédures disponibles
Décaler un nombre x de n rang dans le sens GAUCHE ou DROITE:
Fonction décaler (x : entier non signé 32 bits, n : entier 32 bits , sens : boolean):entier non signé 32 bits
Exemple x= décaler(128,1,DROITE)
Les opérateurs ET / OU bits à bits sont utilisables
3. Ecrire l'algorithme de la procédure qui permet de modifier l'exposant d'un réel FSP (on suppose 128<e<127)
Procedure set_exposant (*x : FSP , e : entier signé 32 bits)

la je n'ai pas bien compris

Mis à part si le résultat final est toujours connu d'avance (cas rare, dans ce cas un XOR peut être utilisé), tu ne peux pas couper au fait de prendre deux masques.

[Mac LAK]

j'ai un exo voila la consigne

Nous allons décrire les algorithmes permettant de lire et modifier l'exposant et la mantisse d'un réel FSP.
Fonctions et procédures disponibles
Décaler un nombre x de n rang dans le sens GAUCHE ou DROITE:
Fonction décaler (x : entier non signé 32 bits, n : entier 32 bits , sens : boolean):entier non signé 32 bits
Exemple x= décaler(128,1,DROITE)
Les opérateurs ET / OU bits à bits sont utilisables
3. Ecrire l'algorithme de la procédure qui permet de modifier l'exposant d'un réel FSP (on suppose 128<e<127)
Procedure set_exposant (*x : FSP , e : entier signé 32 bits)

OK. En fait, c'est plus simple que ce qu'il semblait.
Tout le "noeud" du problème se résume à savoir quels sont les bits correspondant à l'exposant : par exemple, sur un réel codé sur 32 bits, tu peux avoir 12 bits d'exposant, ou 8, ou 16 : à priori, on ne sait pas pour tes réels FSP (et tu ne l'as pas indiqué).
Mettons que ce soient les 8 derniers bits (ce qui correspondrait avec la plage de valeurs de ton "e"). Dans ce cas, ton algo est le suivant :
- Annuler les 8 derniers bits du réel, correspondants à l'ancien exposant : *x = *x AND 0xFFFFFF00
- S'assurer que l'exposant est bien sur 8 bits en annulant les 24 bits (32-8 ) de poids fort : e = e AND 0x000000FF
- Combiner le nouveau réel et son nouvel exposant grâce à un OR (car ils n'ont plus de bits "utiles" pouvant être en commun désormais) : *x = *x OR e.

Code :

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

1
2
3
4
Procedure set_exposant (*x : FSP , e : entier signé 32 bits) ;
DEBUT
     *x = (*x AND 0xFFFFFF00) OR (e AND 0x000000FF) ;
FIN

Tout est OK ?

la je n'ai pas bien compris

Mis à part si le résultat final est toujours connu d'avance (cas rare, dans ce cas un XOR peut être utilisé), tu ne peux pas couper au fait de prendre deux masques.

Pas grave, discussion de puristes : oublie le XOR pour l'instant si ça t'embrouille, après tout tu n'en as pas besoin ! ;-)

[bolo]

Tout le "noeud" du problème se résume à savoir quels sont les bits correspondant à l'exposant : par exemple, sur un réel codé sur 32 bits, tu peux avoir 12 bits d'exposant, ou 8, ou 16 : à priori, on ne sait pas pour tes réels FSP (et tu ne l'as pas indiqué).

c les nombre sont au format simple dc l'exposant est de 8 bits

Mettons que ce soient les 8 derniers bits (ce qui correspondrait avec la plage de valeurs de ton "e"). Dans ce cas, ton algo est le suivant :
- Annuler les 8 derniers bits du réel, correspondants à l'ancien exposant : *x = *x AND 0xFFFFFF00

un chiffre au format FSP
ce n'est pas
signe exposant mantisse ?

- S'assurer que l'exposant est bien sur 8 bits en annulant les 24 bits (32-8 ) de poids fort : e = e AND 0x000000FF

la je n'ai pas bien compris pourquoi il fallait s'assurer que l'exposant etait sur 8 bits

- Combiner le nouveau réel et son nouvel exposant grâce à un OR (car ils n'ont plus de bits "utiles" pouvant être en commun désormais) : *x = *x OR e.

Donc en fait comme les 8 bits de x qui correspondent a l'exposant sont a 0, lorsque l'on fait OR apres tous les bits a 1 de e deviennent a 1 dans x*
c'est bien ca

[Mac LAK]

c les nombre sont au format simple dc l'exposant est de 8 bits

OK, mais QUELS bits sur les 32 ? ;-) Voilà, c'est pas plus compliqué que ça... Ni plus dur, d'ailleurs !

un chiffre au format FSP
ce n'est pas
signe exposant mantisse ?

Ben... Tous les réels en virgule flottante sont codés comme ça, alors ça n'aide pas des masses. Mais je pense honnêtement que ce sont les 8 derniers bits.

la je n'ai pas bien compris pourquoi il fallait s'assurer que l'exposant etait sur 8 bits

Si ton exposant est entre -128 et +127, ça veut dire qu'il est codé sur 8 bits, signés. OK jusque là ?
Bon, maintenant, imaginons que je veuille mettre 45123 comme exposant. C'est idiot, c'est en dehors de la plage, mais comment s'en assurer ? Tout simplement en faisant un masque binaire sur les bits "utiles", ou plutôt les bits "autorisés". Ainsi, même si l'exposant est faux, tu ne "pourris" pas ton réel (seul l'exposant va "charger", mais il était faux dès le départ => on s'en fout).

Donc en fait comme les 8 bits de x qui correspondent a l'exposant sont a 0, lorsque l'on fait OR apres tous les bits a 1 de e deviennent a 1 dans x*
c'est bien ca

Ouaip, c'est exactement ça ! Et c'est (aussi) pour ça qu'il est impératif de s'assurer que ni la mantisse, ni l'exposant ne "débordent" l'un sur l'autre => on tronque la mantisse à 24 bits, et l'exposant à 8 bits.

C'est OK pour toi ?

[cyber_N]

Ce que tu as l'air de montrer est un décalage binaire.

si tu veux décaler les bits vers la droite:
c'est: (nombredecimale) divisé par (2 puissance le décalage)
vers la gauche:
c'est: (nombredecimale) multiplié par (2 puissance décalage)

et tu reconverti en binaire le nombre décimale.

ex: 100 (1100100) décalé vers la gauche de 2 = 400 (110010000).
(calcul : 100 * (2 puissance 2) = 400).

EST JE REPONDU A TA QUESTION ??

[SKZ81]

Sauf que "tronquer", à proprement perler, me paraît dangereux...
Le principe reste identique, mais plutôt que de l'utiliser pour virer les erreurs (s'cuse Mak, mais si les exposants/mantisses sont faux dès le départ, on s'en fout PAS DU TOUT), il vaut mieux utiliser le "reste" de la troncature, tester que c'est égal à zéro (que rien n'a été tronqué), pour affirmer que tout est valide...

Et si jamais il y a un dépassement, hé bien, balance une execption, return(-1) en c/c++ expériemental, je sais pas... Mais signale l'erreur...

Edaxi ?

[Mac LAK]

Effectivement, on peut utiliser le même principe pour "tester" l'exposant :
SI ((e AND 0xFFFFFF00)<>0) ALORS ERREUR SINON SUITE_DU_CALCUL FINSI

En implémentation, c'est même souvent un truc genre assertion qui s'en occupe... Mais tu avoueras qu'en algo "basique", en général, on ne teste que rarement les cas limites, on utilise plutôt des préconditions !
Mais en implémentation, c'est vrai qu'il faut bien les tester à un moment ou à un autres, ces fameuses préconditions... ;-)

[EDIT]Tronquer est dangereux d'un point de vue erreurs de calcul, c'est vrai. Par contre, ça permet en général de conserver l'intégrité du nombre, et donc souvent les postconditions, voire l'invariant...[/EDIT]