Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox
Vous êtes dans la section des pages en cours de rédaction. Cette page n'est pas terminée, et peut contenir des informations erronées.
EN CHANTIER
Cette page n'est pas terminée et est en cours d'écriture.

Le binaire et ses opérateurs

Par hubeert (hubeert), le 22 mai 2011
Prérequis Il n y a rien a savoir de précis ce tutoriel est accessible à tout le monde la manipulation des opérateurs sur les bits est simple. Plus délicat est de déterminer les modèles sur lesquels on peut les utiliser. Le but de ce tutoriel étant de vous familiariser avec les opérateurs sur les bit ainsi que de leur utilisation dans la pratique.

Pour quoi faire en pratique ?

  • Pour ceux qui veulent voir la programmation autrement.

Les opérateurs sur les bits semblent plus compliqués à comprendre et leur utilité ne saute pas aux yeux. Ils sont communs à beaucoup de langage ; cependant ici nous nous borneront à l'AS. Ceci n’est pas un tutoriel mathématique. Mais un tutoriel pour apprendre a se servir de ces opérateurs dans des cas précis et des situations précises.

  • Pour les jeux ( grille; hitTest intelligence artificielle)
  • Banques de données
  • la couleur
  • Dans tout type d’informations relevant du « true » ou « false »
  • Dans les domaines ou seule votre imagination vous mènera. ☺

Il nous faut avant tout les connaître et savoir nous en servir. Par la suite Des exemples précis agrémentés de code montreront leurs utilités

Avant propos

qu'est ce une base ?

En arithmétique une base désigne la valeur dont les puissances successives interviennent dans l'écriture des nombres dans leur mode de représentation. Ces puissances définissant l'ordre de grandeur de chacune des positions occupées par les chiffres composant tout nombre.

En base 10 le nombre est représenté par dix chiffres allant de 0 a (10 -1)

119= 10^2 + 10^1 +9

en base 2 ( systeme binaire) est représente par deux chiffes allant de 0 a (2-1).

119 ou 1110111 = 2^6 + 2^5 + 2^4 + 2^2 + 2^1+ 2^0

le bit 3 étant ignoré car valant 0.

On nomme couramment bit (de l'anglais binary digit, soit « chiffre binaire ») les chiffres de la numération binaire positionnelle. Ceux-ci ne peuvent prendre que deux valeurs, notées par convention 0 et 1.

Et ce sont ceux la qui nous intéressent

Afin de visualiser les nombres dans les deux bases nous nous servirons de deux fonctions.
 
Variable.toString(base) // (ici base 2) pour transformer un nombre en base 2.
 
parseInt(variable,base) //qui d’une chaine extrait un entier.
 
 var code:uint  =15 ;
 
 var codeChaine:String=code.toString(2);
 
 trace( codeChaine);// écrit : 1111
 
 trace(parseInt(codeChaine,2));// écrit:  15

Si vous avez une calculette et quelle puisse se mettre en mode programmation cela sera tout aussi explicite

ou servez vous ce petit visuel.

L"extension Adobe Flash Plugin est nécessaire pour afficher ce contenu.

transformer un nombre décimal en base 2

Un nombre binaire est stocké sous forme de 1 et de zéro représentant le nombre en base 2.

Comme ceci : 100010 qui représente 34 en décimal chaque un ou zéro est appelé bit.

Le bit le plus a droite a le rang zéro puis 1 2 3 etc.

La valeur numérique du bit est égal a la base élevée a la puissance de son rang (poids du bit) .

Pour le bit zéro = 2^0 c'est à dire égale 1

Pour le bit 3 =2^3 c'est à dire huit en décimal.

Nous savons que les chiffres 1 ou zéro sont équivalent aux valeur booléennes true ou false de cette manière il est simple avec les opérateurs sur les bits d’utiliser les bits comme la représentation vrai ou fausse de quelque chose que nous auront déterminé auparavant.

cela peut être sur un bit mais aussi sur un ensemble de bit appelé flag.

Un bit qui a la valeur 1 est défini il est a true

Un bit qui n’est pas défini ou effacé est a false.

Les opérateurs

L'opérateur & appelé ET binaire

Il prend la forme suivante . opérande1 & operande2 l'opérande étant le paramètre faisant l'objet d'une opération. Les opérandes deviennent des nombres convertis en entier binaire sur 32 bit.

C’est a dire entier. en AS3 on se servira uint c'est à dire d’entier sur 32 bit non signé. (positif)

L’opérateur retourne un nombre dont la valeur est déterminée par comparaison des bit numériques un a un. Si un bit est a 1 dans chaque opérande le bit correspondant sera défini a 1 dans le résultat.

Sinon il sera défini a 0.

A quoi ca sert ?

  • A verifier si un flag ou un jeu de flag ( les bits) sont true ou false.

Ex : je veux vérifier si le bit 2 est a true c'est à dire sil vaut 4 représenté par un bit égal à 1. Le bit 2 de maVariable est 1111 (pour compter les bit on part de droite vers la gauche en commençant par 0)

trace( maVariable & 4) donne 4 donc le bit 2 est bien a true Voici l’opération telle quelle est faite. 4 s’écrivant en binaire 100;

(Nous verrons plus tard comment calculer la valeur correspondant a la position d’un bit ) (2^y)

1111

&

0100

__

0100

1 et 0 donne 0 ;

1 et 0 donne 0 ;

1 et 1 donne 1 ;

1 et 0 donne 0 . soit 100 en binaire et 4 en décimal ; 4 étant la valeur du bit 2. (2^y)

  • A a définir un bit a false. (Nous le verrons plus tard avec l’opérateur ~)
  • Accessoirement et de manière anecdotique il permet de savoir si un nombre et pair ou impair.

maVariable vaut 15 si je fais trace ( maVariable & 1) renvoi 1 c'est à dire impair ; renvoi 0 dans le cas contraire.

L'opérateur & en pratique

Voilà l’opérateur & un peu moins obscur.. il nous reste a voir celui ci en combinaison avec d’autre opérateur..Cela reste encore très impénétrable sans doute et que pouvons nous faire a ce niveau la de concret avec cet opérateur ?

Considérons une balle elle peut avoir 4 couleurs différentes ; bleu, jaune,vert ou rouge être unie avoir deux ; avoir trois ou avoir quatre couleurs.

On vous demande d’un point de vue informatique de trier les balles les unies bleus ensemble ; les bicolores de même couleur ensemble etc etc.

si vous devez faire une fonction vous aller devoir chercher toutes les balles rouges ; puis toutes les vertes puis les vertes et rouge et le bleu et jaune et les rouges et jaune ! Vous aller écrire ceci.. si la balle est rouge met la dans le sac qui contient les balles rouges Si elle est rouge et jaune met la dans le sac rouge et jaune et comme ceci jusque a épuiser toutes les combinaisons.

Mais ; mais vous êtes pas bête ;-) et vous avec entendu parler des opérateurs binaire.

Il y a 4 couleurs.

Arbitrairement on décide que le rouge est représenté par 1000 en binaire soit 8 en décimal.

ca veut dire que le bit 3 est a 1 ( a true)

Le vert ca sera 0100 soit 4 en décimal ca veut dire que le bit 2 est a true

Le bleu sera 0010 soit 2 en l bit 1 est a true et enfin le jaune 0001..

La rouge et bleu sera ? 1010 ;-)

Il nous reste plus qu’a analyser notre 2768 balles…Mais comme on va le faire dans un langage natif de l’ordi cela va aller extrêmement vite. Comment faire. Si vous le faite a la traditionnelle vous allez être obligé de rechercher toutes les combinaisons possible ; bleu et rouge ; bleu et vert ; vert rouge et jaune Pfouiiiiiii.. la c'est facile

1111 cest a dire les 4 couleurs correspondent a 15 en décimal.. il y a donc 15 combinaisons possibles et différentes. Commençons par le début

1 elle est jaune

11 jaune et bleu

111 jaune bleu vert

1111 jaune bleu vert rouge

101 jaune et vert .. etc etc

comment écrire la rouge et verte ? Je vous laisse faire.

Et comment trier ??

On a notre gros sac de balles avec nos 2768 éléments. Comme c’est de l’informatique c’est un tableau..

Il est comme ca ; sac=[ 0100,1000,1011, etc 2768 fois ]

Mais plutôt comme ca ; sac=[ 1,12,8,15,3 , etc 2768 fois ]

On extrait une balle du sac et on l’examine.. la première est verte on la met dans le sac ou les balles sont que verte.

L’ordinateur il voit rien lui on lui présente la balle et celle ci grâce a la variable number est identifiée

Il veut juste savoir les couleurs . si le bit zéro est true c’est jaune. Si c'est le bit 1 c’est bleu ; si c’est le deux et le un c’est jaune et bleu. Il regarde le bit 0 s’il est true la balle est jaune.

sac[valeur0] & 1 = renvoi 0 , false ( elle est pas jaune) sac[valeur1] & 2 =renvoi 0 false ( elle est pas bleu) sac[valeur2] & 4 = renvoi 4 ; true ( elle est verte) sac[valeur0] & 8 = false ( elle est pas rouge) elle est que verte elle égale 100 soit 4 en décimal. donc dans 15 variable de type Number on stocke toutes les combinaisons possibles de toute les balles.. c’est plus simple que de faire

lesBalles1= « jaune »

etc lesBalles12= « rouge » et « verte »..

donc avec deux boucles;

 
 
 
var  sac:Array=[1,12,13,15,8,3,14,2,3,1,11,9,10,7,5,3,12,15,8,7,4,9,11,13,14,15,12,13, 1,12,13,15,8,3,14,2,3,1,11,9,10,7,5,3,12,15,8,7,4,9,11,13,14,15,12,13,14,12,2,1,5,7,9,12,15, 9,10,7,5,3,12,15,8,7,4,9,11,13,14,15,12,13,14,12,2,1,5,7,9,12,15, 9,10,7,5,3,12,15,8,7,4,9,11,13,14,15,12,13,14,12,2,1,5,7,9,12]
//On crée nos 15 sacs..
 var  petitSac:Array= new Array ()
 
for (var  i:int  = 1 ; i< 16 ;i++) {
 petitSac[i]=[];}
 
 var longueurTableau:int  =sac.length; 
 
for ( var k:int  =0 ; k< longueurTableau  ;k++) {
for (var  j:int  = 1 ; j< 16 ;j++) { 
if ( sac[k]==j ) {petitSac[j].push(sac[k]) ;}}}

Nous avons donc trié nos balles en leur imputant une valeur numérique. Nous n'avons pas encore appris à imputer une valeur. Empiriquement nous avons supposé qu'il y avait 15 possibilités pour les combinaisons ; Sachant qu'en le testant avec l'opérateur & (même si on ne sait pas le faire) au cas où le bit auquel nous avions attribué un code couleur était true ça signifiait que la balle possédait cette couleur.

Merci à Didier de Mediabox pour son aide à écrire en AS3

Afin d’illustrer ce que à quoi peut servir l’opérateur & nous avons maintenant nos petitSac remplis de balles identiques mais sur les petitSac il y a marqué 15 ou 8 ou 7 et c'est pas très explicite pour la vendeuse qui cherche une balle toute rouge ou une balle jaune et verte.

On va faire un petit programme pour imprimer des affichettes rendant compte du contenu des « petitSac »

Mais.. pour pouvoir utiliser l’opérateur & reportez vous plus loin afin d’avoir des explications sur la sélection dynamique des bit.(les opérateurs de décalage)

Nous savons que le

jaune est représenté par le bit 0

bleu est représenté par bit 1

vert par bit 2

rouge par bit 3

on va analyser nos variables avec l’opérateur & qui sert principalement a voir si un bit est a true ou false.

on va lui dire s’il y a du vert dans la balle ajoute vert sur l étiquette et pareil pour les autres couleurs. Nous avons donc 15 variables a analyser qui ont elles mêmes 4 bit de significatif.

 
 
etiquettes:Array= new Array();
	for( var i:int=1; i<16;++i) {// nos 15 variables ont commence a 1 car nous n'avons pas de balles sans couleur
		etiquettes[i]="";// on rends nos etiquettes vierges
		for(var j: int=0 ;j<4;++j) { //on teste les 4 bit
			if( (i & Math.pow(2,j))  ){ 
			// la on ecrit si la variables ici i  a le bit 0 a true cest a dire egale a 1(je sais cest pas simple)
			//ou le bit 1 egale a 2 ou le bit 2 egale a 4 ou le bit 3 egale a 8  verifie les conditions suivantes
 
			// si j egale 0 a ce moment la cest que  cest le bit zero qui est a true donc il y a du jaune on met jaune
			//sur letiquette.
			// si j egale 1 a ce moment la cest que  cest le bit un qui est a true donc il y a du bleu on met bleu
			//sur letiquette. ainsi desuite jusqu'a la derniere variable
				if(j==0) { etiquettes[i] ="jaune  ";}
				if(j==1) { etiquettes[i] +="bleu  ";}
				if(j==2) { etiquettes[i] +="vert  ";}
				if(j==3) { etiquettes[i] +="rouge  ";}
 
			}
		}
 
	trace(i +"   "+etiquettes[i])}

voici le résultat du trace.

1 jaune; 2 bleu; 3 jaune bleu ;4 vert; 5 jaune vert; 6 bleu vert ; 7 jaune bleu vert; 8 rouge; 9 jaune rouge; 10 bleu rouge; 11 jaune bleu rouge; 12 vert rouge; 13 jaune vert rouge ; 14 bleu vert rouge; 15 jaune bleu vert rouge;

et nous avons plus qu’a mettre les étiquettes imprimées sur les petitSac correspondants.

L'opérateur | appelé OU binaire ou OR

Il prend la forme suivante;

opérande1 | operande2

L’opérateur retourne un nombre dont la valeur est déterminée par comparaison des bit numériques un a un.

Cet opérateur fait un OU inclusif bit à bit : il donne 1 si l'un ou l'autre des deux bits de même poids est à 1, ou si les deux sont à 1.

1111

0100


1111

A quoi ca sert ?

  • A combiner plusieurs nombres qui représentent des valeurs individuelles.

Dans l’exemple très simple des balles on peut par exemple vouloir savoir quel nombre représente la balle jaune rouge verte.. Ici c’est simple a faire de tête mais dans le cas ou la variable est codée sur 28 bit ça peut s’avérer compliqué ; ou dans une boucle pour générer des variables. ; Ex : je veux la valeur de la variable représentant la balle tricolore rouge vert jaune.

trace( maBalleTricolore = 8 | 4 | 1)

	trace(maBalleTricolore)  c’est 13
	trace(maBalleTricolore.toString(2) ) cest  1101 qui correspond bien aux bits que nous avons déterminés.

Donc çà sert a mettre un bit ou plusieurs à true. très important si on veut manipuler les données binaires de vérifier si un bit est a true ( opérateur &) ou de mettre un bit ou plusieurs spécifiques à true (opérateur | )

L'opérateur ^ appelé XOR ; OU exclusif

Prend la forme opérande1 ^opérande2.

Examine les bits renvoi zéro pour les bit identiques ; renvoi 1 dans l’autre cas. Il est utilisé pour basculer les bit choisis a true ou false (un ou zéro) dans certains cas ou lorsque on ne connaît pas la valeur du bit que l’on veut basculer il vaut mieux se servir de l’operateur NON ( ~) que nous allons voir ensuite..

1111

^

0100


1011

Dans mon exemple j’ai une balle multicolore avec les 4 couleurs.. mais en fait en l’examinant bien je vois quelle n’a pas de vert trace ( 15 ^ 4) soit 1111 ^ 100 et hop ma balle tricolore perd le vert.

Il est aussi utilisé pour comparer. J’ai une balle bleu.

soit 10 et je veux savoir ce qui lui manque comme couleur pour en faire une balle bleu rouge et jaune.

Bien entendu en français ça tombe sous le sens mais l’ordi lui il sait pas Ma balle rouge bleu jaune soit 1011 Ma balle bleu 10 Donc trace( 1011 ^ 10) donne 1001 il faut du rouge et du jaune soit commuter le bit 3 et 0

Mais aussi comparer deux valeurs pour savoir si elle sont égales ; bien sur sur 4 bit c’est facile a faire mais sur 32 !! donc si maValeur1 ^ maValeur2 égales 0 c'est que les deux variables sont égales.

XOR a aussi cette particularité:

a ^ b = c

c ^ b = a

de cette manière on peut crypter

(secret) ^ (cle) = (secret_crypté)

(secret_crypte ^ (cle) = (secret)

L'opérateur ~ appelé NON ou NOR

Il inverse les bit de l’opérande.

Dans le domaine qui nous intéresse il est typiquement utilisé avec l’opérateur & pour basculer un bit a false ;

c'est a dire définir des bit spécifiques a zéro.

Sous cette forme maVariable = 11 c'est a dire 1011 en binaire je veux enlever le bleu c'est a dire définir le bit 1 a zéro .. On peut faire bien sur 1011 ^10

et nous aurons bien ôté le bleu mais c’est risqué car si par hasard j me suis trompe et la balle n ‘avait déjà pas le bleu je vais lui rajouter le bleu en fait.

Dans le cas ou on est pas s certain d’un valeur il vaut mieux faire maVariable on met un masque ici avec l’opérateur NON et on combine les deux nombres avec l’opérateur & en clair maVariable = maVariable & ~ 2

Décomposons.

maVariable c'est celle à qui je veux enlever le bleu soit le bit 1 à mettre à false elle vaut 11 soit 1011

mon masque c’est ~10 (en binaire) soit 1101 l’opérateur ~inverse les bit ; et j’ai omis les 28 autres bit car ils sont tous défini a 1 donc nous avons 1011 & 1101 (mon masque )

1001

j’ai bien enlevé le bleu.

Entrainez vous sur une calculette !

Sans risque de rajouter quoique ce soit.

Les operateurs de décalage

Décalage a droite signé » et a gauche «

Je le répète ce tutoriel n’a aucune vocation mathématique ou scientifique. ;-) Ce qui nous intéresse ici c’est la notion de décalage. Supposons qu’au lieu d’avoir des valeurs qui représentent des couleurs nous ayons une valeur qui représente la place d’un personnage sur les coordonnées x dans un jeu. j'ai 32 positions qui sont vides. Soit 00000000000000000000000000000000

Je place un perso a 3 positions a partir de la droite

Soit 00000000000000000000000000000100 en binaire il est représenté par 100 soit le bit 2 est a true

Je veux déplacer mon perso de deux cases vers la gauche

Du bit 2 je veux le mettre au bit 5

Je fais 4«3 je pousse le bit 2 de 3.

Je sais qu’il est difficile de passer mentalement de base 10 en base 2

Mais en fait on fait un multiplication en base 10 4 * (2^3) ca donne 32 qui est bien 100000 en binaire. si on le remet dans l’exemple.

00000000000000000000000000100000

voilà mon personnage a 3 place plus loin vers la gauche.

L’avantage c'est que l'on peut déplacer tous les bit en même temps.

pareil pour le décalage a droite.

L’opérateur de décalage a gauche est pratique pour sélectionner dynamiquement les bit grâce a un indice numérique au lieu d’une valeur.

1«0 cest le bit zéro qui égale 1

1«1 c’est le bit 1 qui egale 2

1«2 cest le bit 2 qui egale 4 etc

1« 11 plus facile a se rappeler que le bit 11 égale 2048.

Puisque nous en sommes aux représentations vous aurez remarqué que la place du bit en représentation décimale donne un nombre qui est l’exposant auquel il faut élever 2 pour avoir la représentation décimale de celui ci .

Nous avons en Action script Math.pow(base, exposant) qui fait ce boulot tout a fait convenablement.

Ici Math.pow(2,exposant)

A ce stade c’est toujours surement encore très obscur. mais patience on avance.

Certains operateur sur les bit peuvent faire des affectations composées au niveau du bit.

écrire :

maVariable &= un autreVariable est possible.

maVariable |= unautreVariable est possible.

maVariable ^= unautreVariable est possible.

idem pour les opérateurs de décalage.

Et d’ailleurs c’est cet emploi qui en est le plus souvent fait…

Résumé :qui fait quoi?

Exercices

Continuons par un petit exercice avec nos balles multicolores.

Nos balles sont triées par sac avec sur chaque sans son étiquette correspondante.

Nous allons les vendre.

Notre études sur les habitudes d'achat montre ceci :

Les balles rouges sont les plus vendues.

Puis les rouges jaune et bleu.

Suivi de celles contenant du rouge.

Puis celles contenant du bleu.

Les autres.

Nous allons faire 5 prix différents.

Le prix de base est de 1 euro , il correspond aux balles n'ayant pas de rouge ni de bleu.

On rajoute 0,05 centime si elles contiennent du bleu.

On rajoute 0,10 centime si elles contiennent du rouge.

On rajoute 0,20 centime si elles sont tricolore rouge jaune bleu.

on rajoute 0,30 centime si elles sont toute rouge.

Comment calculer tout ca et éditer un tarif de manière simple?

En fait il suffit tout simplement d'analyser nos 15 variables et nous avons maintenant les outils nécessaire pour le faire.

Nous arrivons a des écritures peu familière mais qui sont terriblement efficaces.

Rappel:

On peut sélectionner un bit dynamiquement grâce a un indice numérique au lieu d'une valeur. cet indice correspond a son rang .Le poids d'un bit égale 2 a la puissance de la place (de l'indice) qu'il occupe dans le nombre .Nous pouvons le faire de deux manières.

Avec l’opérateur de décalage a gauche exemple je cherche la valeur du bit 11. c'est égal a : 1«11

Avec Math.pow(base,exposant). c'est égal Math.pow(2,11).

On peut se servir des deux notations.

voici le résultat en code.Nous allons nous resservir d'un code édité avec l'opérateur & afin d'avoir nos sac triés par nom et le code qui obéi aux conditions induites par l'étude de marché.

var etiquettes:Array= new Array();
	for( var i:int=1; i<16;++i) {// nos 15 variables ont commence a 1 car nous navons pas de balles sans couleur
		etiquettes[i]="";// on rends nos etiquettes vierges
		for(var j: int=0 ;j<4;++j) { //on teste les 4 bit
			if( (i & Math.pow(2,j))  ){ 
			// la on ecrit si la variables ici i  a le bit 0 a true cest a dire egale a 1(je sais cest pas simple)
			//ou le bit 1 egale a 2 ou le bit 2 egale a 4 ou le bit 3 egale a 8  verifie les conditions suivantes
 
			// si j egale 0 a ce moment la cest que  cest le bit zero qui est a true donc il y a du jaune on met jaune
			//sur letiquette.
			// si j egale 1 a ce moment la cest que  cest le bit un qui est a true donc il y a du bleu on met bleu
			//sur letiquette. ainsi desuite jusqu'a la derniere variable
				if(j==0) { etiquettes[i] ="jaune  ";}
				if(j==1) { etiquettes[i] +="bleu  ";}
				if(j==2) { etiquettes[i] +="vert  ";}
				if(j==3) { etiquettes[i] +="rouge  ";}
 
			}
		}
	}
 
	trace(etiquettes)
 
 
var tarifBase:Array=new Array();
 
 for( var k:int=1;k<16;++k){
	 tarifBase[k]=1;
	 //On traite la balle dans son ensemble 
	 if( k & 1<<3 && k & 1 << 1 && k <<0) {tarifBase[k] +=0.2; }// s'il y a du jaune et du bleu et du rouge.
	 if( k & 1<<3 && (k & 1<<2)==0 && (k & 1<<1)==0 && (k & 1<<0)==0 ) { tarifBase[k] += 0.3;}// s'il y a que du rouge
	 for( var l:int=0;l<4; l++){
		 // on traite la balle couleur par couleur.
		 if( k & Math.pow(2,l)) {
			if(l==1) {  tarifBase[k] += 0.05; }// s'il y a du bleu;
			if(l==3) {  tarifBase[k] += 0.1  }// sil y a du rouge;
			}
	 }
 
trace( etiquettes[k]+ "  =   "+ tarifBase[k] + " € ")}

Nous avons fini avec les opérateurs. Cet exercice pour montrer qu'avec les opérateurs sur le bit on peut résoudre une problématique de manière simple et élégante et de manière optimisée.

Nous verrons a l'aide d'autre exercices commet se servir des opérateurs d' imputation composée.

Conclusion

Même si cette première approche est un peu hermétique elle est absolument nécessaire.

Le plus intéressant dans l'étude des opérateurs sur le bit est la modélisation du problème afin de le résoudre avec ces opérateurs. Ici par exemple plutôt que de traiter chaque balle par son nom soit

balle1=“jaune”

balle15=“jaune”+“bleu”+“vert”+“rouge”

on attribue a chaque balle une valeur décimale correspondant a un ensemble de valeur vraies ou fausses représenté par un nombre binaire.

La partie suivante traitera des bases de donnée.

opérateurs binaires et Base de données

Le binaire dans les jeux : "hitTest"

Généralité sur les opérateurs binaires,Par Thoutmosis

Le binaire et la representation des nombres,Par Thoutmosis