Les articles Amstrad >Les produits Amstrad > Les CPC > Programmation > Assembleur > 1 : Les bases de nombres [fr-en] (Amstradeus)

1 : Les bases de nombres [fr-en] (Amstradeus)

[fr]

On sait tous compter jusqu'à dix, cent, mille, dix mille... et même jusqu'à plusieurs millions...


Mais pour ce petit cours, on s'arrêtera à a peu près soixante cinq mille et des poussières. Nous verrons pourquoi ultérieurement...

Pour comprendre ce qui va suivre, il faut faire la distinction entre les nombres et les chiffres.
En gros, les nombres sont infinis, un million est un nombre. Par contre, les chiffres sont une méthode de représentation des nombres. Nous décrivons les nombres avec dix chiffres, qui vont de 0 à 9. (Pour faire le rapport avec l'alphabet, nous décrivons les mots avec vingt six lettres, de A à Z.) Lorsque nous avons atteint 9, pour décrire le nombre suivant, il suffit d'ajouter le chiffre 1 et le chiffre 0, ce qui donne dix. Cette méthode de représentation des nombres n'est pas unique.


En fait, nous représentons les nombres en base dix. Pourquoi base dix ? Parce que nous utilisons 10 chiffres. Maintenant, imaginons qu'il n'y a que deux chiffres possibles, le 0 et le 1. Dans ce cas, on dit que l'on est en base deux, car seuls deux chiffres existent.


Pour compter jusqu'à un, pas de problèmes, 0 puis 1. et maintenant le nombre deux ? Et bien, comme nous n'avons plus de chiffres disponibles, on va faire comme on faisait en base dix, on ajoute un chiffre devant et on recommence, ainsi, notre deux va se représenter 10.


Et trois ? Et bien trois en base deux se représente 11. En fait, on augmente le chiffre le plus à droite. Lorsque celui-ci a atteint son maximum, il repasse à zéro (le premier chiffre de toutes les bases est le zéro) et on augmente le chiffre suivant à gauche. Si ce dernier a également atteint lui aussi son maximum, on répète l'opération : on le repasse a zéro et le chiffre le plus à gauche est augmenté, et ainsi de suite.

[/fr][fr]


Voici donc un exemple de représentation des seize premiers nombres en base deux :

 
J'ai volontairement aligné les valeurs en base deux à droite, ce qui permet de bien voir que le chiffre le plus à droite est toujours augmenté, ensuite c'est le chiffre suivant à gauche, et ainsi de suite. Je me suis également volontairement arrêté à quinze, nous verrons pourquoi plus tard.
Mais sachez quand même que le seize se représente ainsi : 10000 (cinq chiffres !)

Quelques termes à savoir : la base dix est appelée base décimale, ou plus couramment le décimal. La base deux est appelée base binaire, mais plus couramment le binaire.


Un groupement de 8 bits et appelé octet (en référence à octal, qui signifie 8). Mais à quoi ça peut bien servir de compter en binaire ? Et bien en fait, le microprocesseur Z80 (et tous les microprocesseurs) ne savent compter qu'en binaire. Et pourquoi qu'ils ne savent compter qu'en binaire les microprocesseurs ? Parce que les informations qu'ils traitent sont représentées sous forme de tensions électriques, et en gros, ils ne savent distinguer que deux sortes d'informations : une tension est présente, ou il n'y a pas de tensions présentes.


En gros, on peut comparer un microprocesseur à une ampoule, et l'information qu'il a à traiter à l'interrupteur qui commande l'ampoule. Quand on actionne l'interrupteur, l'ampoule s'allume. Quand on actionne l'interrupteur dans l'autre sens, l'ampoule s'éteint. L'ampoule travaille donc en binaire, elle ne connait que deux états, éteinte, que l'on peut faire correspondre à l'état zéro, et allumée, que l'on peut faire correspondre à l'état un.

[/fr][fr]


Et voilà que nous avons crée notre premier programme en language machine : l'allumage de l'ampoule !
Plus sérieusement, c'est l'un des principes primordiaux des microprocesseurs, le traitement des informations en binaire.

Mais comment ils font pour traiter des grands nombres, les microprocesseurs ? Et bien, comme nous l'avons fait tout à l'heure dans notre exemple pour compter jusqu'à quinze en binaire, ils ajoutent des chiffres.


Et c'est là qu'intervient la notion de 'bit'. Quoi ? Qu'est ce que c'est que ça ? Me direz-vous... Plutôt que de parler de chiffres, qui eux vont de zéro à neuf, on parle de bits pour la représentation des nombres en binaire.
Donc, pour résumer, un bit est un élément qui prends la valeur 0 ou 1, et qui sert, lorsque l'on en associe plusieurs, à représenter des nombres en binaire. Et notre bon vieux Z80 étant un microprocesseur huit bits, cela signifie qu'il est capable de traiter des nombres représentés par un regroupement de huit bits.

[/fr][fr]


Mais ça va jusqu'à combien, un nombre de huit bits ? Plutôt que d'essayer d'écrire toutes les combinaisons possibles des huit bits pour arriver au maximum (qui sera représenté par 11111111), il existe des formules mathématiques simples pour connaître le nombre maximal représenté par un groupement de chiffres dans une certaine base. Si nous revenons en décimal, il est facile de savoir que l'on représente les nombres de zéro à neuf avec un chiffre (soit dix nombres différents), de zéro à quatre vingt dix neuf avec deux chiffres (soit cent nombres différents) et ainsi de suite. La formule mathématique pour le décimal est : 10 puissance nombre_de_chiffres.
Par exemple, si nous utilisons quatre chiffres, on peut représenter : 10 puissance 4 = dix mille nombres, de zéro à neuf mille neuf cent quatre vingt dix neuf.


Et la formule est générale à toutes les bases, soit :
base puissance nombre_de_chiffres.
Pour notre Z80, nous travaillons en binaire avec 8 chiffres (pardon bits), la formule nous donne : 2 puissance 8 = deux cent cinquante six valeurs, de zéro à deux cent cinquante cinq.
Mais j'ai entendu dire que le Z80 pouvait traiter des nombres de 16 bits ? Et bien oui, il peut traiter des nombres de 16 bits, mais ça, nous le verrons plus tard.


On peut juste remarquer qu'un nombre de 16 bits aura une valeur maximale de... (Sortez les calculettes...) de 2 puissance 16 = 65536, soit de 0 à 65535, et que la représentation en binaire de sa valeur maximale (65535 donc) est : 1111111111111111 (soit seize 1). Pas très pratique comme représentation, n'est ce pas ? Heureusement, il y a un autre moyen de représenter des nombres que le binaire: l'hexadécimal.

[/fr][fr]


Qu'est ce que c'est encore que ce terme barbare ?
L'hexadécimal est en fait le nom couramment employé pour la base 16. La base 16 est donc une base de comptage qui comporte 16 chiffres. les chiffres sont donc 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,... Et après ? Et bien, comme nous n'avons plus de chiffres, symboliquement parlant, pour continuer, on va piocher dans les lettres pour les six symboles qui nous manque, c'est à dire A, B, C, D, E, F.
Ouf ! Pour résumer, la base 16 utilise 16 chiffres qui sont (dans l'ordre) : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.


Si nous revenons à notre petit exemple du début, pour représenter les seize premier nombres en base 16 (hexadécimal), nous écrirons :

 
Et le seize alors ? Et bien, comme pour toutes les bases, on représente le seize ainsi : 10 (avec le F du quinze, on repasse a zéro et on augmente le chiffre immédiatement à gauche).
Si l'on étend cet exemple plus loin, et que l'on fait l'analogie avec les nombres en binaire, on remarque qu'il y a une relation directe entre le binaire et l'hexadécimal : un groupe de 4 bits sera toujours représenté de la même façon en hexadécimal.

En plus, comme 4 bits peuvent représenter un maximum de 16 nombres, c'est exactement ce que peuvent représenter un chiffre hexadécimal !

[/fr][fr]

Voici un exemple :

 
Maintenant, pour plus de lisibilité, on ajoute à gauche les zéros non significatifs, et on sépare en groupe de 4 bits (ou un chiffre hexa...)

 
On remarque donc une forte analogie entre l'hexadécimal et le binaire. Il est donc facile de faire des conversion hexadécimal<->binaire. Ce qui semble plus compliqué que les conversions décimal<->binaire.

Allez, un petit exemple :
convertir :

11011001 (binaire) en hexadécimal ...

Bon, 1101, ca fait D en hexa et 1001 9, donc dans notre exemple, 11011001 fait D9 en hexa !

Un autre ? ok, convertissons : 11110011 (binaire) en hexadécimal... 1111 = F, 0011 = 3, soit F3 !

Une remarque importante, les codes hexadécimal (on préfère parler de codes que de chiffres, car ces 'codes' mélangent chiffres et lettres) peuvent être confondus avec du texte. C'est pourquoi, généralement, on ajoute un symbole devant un nombre hexadécimal, pour indiquer qu'il s'agit bien d'un nombre, et non d'un nom quelconque !

[/fr][fr]


Ce symbole est en général le dièse (#) ou le 'et' commercial (&). Donc, nos deux nombres hexa des exemples précédents se représentent ainsi : #D9 ou &D9 et #F3 ou &F3.
Pour le binaire aussi, on utilise un caractère qui permet de faire la différence entre un nombre binaire et un nombre décimal. Ce caractère est en général le pour-cent (%). On note donc %11011001 et %11110011.

Pas trop compliqué pour l'instant ? Ok, on va corser un peu...
Comment faire les conversions binaire<->décimal ?
Pour convertir un valeur binaire en décimal, c'est assez simple. En fait, comme chaque chiffres binaire ne peut avoir que la valeur 0 ou 1, il suffit de donner un poids à chaque bit de notre nombre binaire. Ce poids sera de plus en plus fort au fur et à mesure que l'on va se déplacer dans les chiffres vers la gauche.


Ainsi, le poids du chiffre le plus à droite est égal à 1, le poids du chiffre immédiatement à sa gauche 2, puis 4, puis 8, puis 16... En fait, il suffit de reprendre les puissances de deux (puisque l'on est en base deux) pour affecter le poids de chaque bits.


Ce qui nous donne :

Numéro du bit 7 6 5 4 3 2 1 0
Poids 128 64 32 16 8 4 2 1

On numérote les bits en général en commençant à zéro pour le bit le plus à droite, car on remarque que deux puissance zéro = 1 (poids) et ainsi de suite... (deux puissance 7 = 128)
Le bit le plus à droite est aussi appelé bit de poids faible. Le bit le plus à gauche est quand à lui appelé bit de poids fort (car c'est lui qui a le plus gros poids...) Prenons un exemple, avec le nombre binaire %10110010.

Numéro du bit 7 6 5 4 3 2 1 0
Poids 128 64 32 16 8 4 2 1
Valeur du bit 1 0 1 1 0 0 1 0

Et là, il suffit d'additionner les poids des bits non nuls, à savoir :
128 + 32 + 16 + 2, ce qui nous donne 178 en décimal !

[/fr][fr]


Facile ? Bon, essayons le sens inverse...
Prenons un autre nombre, par exemple 201 en décimal. Comment convertir 201 en binaire ? C'est à peine plus compliqué. Il suffit de décomposer 201 dans ses puissances de deux, soit les poids d'un nombre binaire.


On remarque que 201 est plus grand que 128, donc, le bit 7 (celui qui a le poids 128) est à 1. Puis, on soustrait 128 à notre nombre, soit 201-128=73. On recommence ainsi pour toutes les puissances de deux, soit jusqu' à 1 (2 puissance 0)
Bon, reprenons depuis le début :

201 - 128 = 73 ( 201 contient 128, bit à 1 )
73 - 64 = 9 ( 73 contient 64, bit à 1 )
9 - 32 < 0 ( 9 ne contient pas 32, bit à 0 )
9 - 16 < 0 ( 9 ne contient pas 16, bit à 0 )
9 - 8 = 1 ( 9 contient 8, bit à 1 )
1 - 4 < 0 ( 1 ne contient pas 4, bit à 0 )
1 - 2 < 0 ( 1 ne contient pas 2, bit à 0 )
1 - 1 = 1 ( 1 contient 1, bit à 1 )

Voila, simple non ? Bon, oui, un peut complexe, mais en s'entraînant, ça devient vite facile, on retient les puissances de deux, et certaines conversions deviennent implicites. Pour la conversion décimal<->hexadécimal, c'est un peu plus compliqué, et je vous conseille de passer d'abord par une conversion décimal<->binaire, puis une conversion binaire<->hexadécimal, très facile.

Maintenant que l'on sait comment le microprocesseur représente les nombres (en binaire), comment il fait pour calculer ?
Et bien, le plus simplement du monde...
Quand nous faisons une addition sur papier, nous procédons ainsi : (addition en décimal)

45
+87
-----
=132
Pour arriver à cela, nous faisons : 5+7 = 12 (je pose 2 et je retiens 1), 4+8+1 (notre retenue)=13, soit 132.

En binaire, c'est pareil, on a une retenue dès que l'on dépasse le plus grand chiffre possible soit 1.

Exemple :

%01001010
+%10111010
----------
%100000100

Si on décompose l'addition, on part de la droite vers la gauche.

- Les deux premier chiffres, 0+0 = 0, facile.
- Ensuite 1+1, en binaire, ca fait 10, on pose 0 et on retiens 1.
- Puis, 0+0=0 PLUS notre retenue, soit 1.
- Ensuite, 1+1 =0, retiens 1, 0+1=1 PLUS retenue = 0 retiens 1,
- Encore, 1+1 =0, retiens 1, 0+1=1 PLUS retenue = 0 retiens 1,
- Encore, 1+1 =0, retiens 1, 0+1=1 PLUS retenue = 0 retiens 1,
- 1+0 = 1 PLUS Retenue = 0, retiens 1
- 0+1 = 1 PLUS Retenue = 0, retiens 1
Et on ajoute notre retenue au final

[/fr][fr]

Ouf !
Maintenant, le même en hexadécimal...
On reprends les mêmes chiffres,

#4A
+#BA
----
#104

Facile avec les conversion... Mais si nous faisons réellement l'addition, cela donne :
A+A = (dix + dix=vingt, soit #14), on pose 4 et on retiens 1.
4+B = (quatre + onze + RETENUE = seize, = #10), on pose 0 et retiens 1.
Et on pose enfin notre retenue, soit #104.

Maintenant que nous savons faire quelques calculs en binaire et en hexa, voyons comment gérer les nombres signés.
Oui, pour le moment, nous n'avons vu que des nombres positifs. Mais comment gérer les nombres négatifs ?
En rajoutant le symbole '-' me direz-vous. Oui... Mais bon, n'oublions pas que nous allons travailler avec un microprocesseur, qui gère des nombres de 8 ou 16 bits (nous verrons cela plus tard), et qui doit pouvoir connaître le signe d'un nombre avec un moyen simple. C'est pour cela que l'on a inventé les nombres signées et les nombres non signés.


Un nombre non signé, dison de 8 bits (un octet en fait), a sa valeur représenté par ces 8 bits. Un octet signé (un octet fait 8 bits), a sa valeur représenté par 7 bits seulement (les bits de poids le plus faible). Et le huitième bit ? Il sert de bit de signe.


Evidement, en supprimant un bit pour la valeur, on ne peut plus aller que de 0 à 127. Et avec le signe ?
Pour comprendre le fonctionnement du bit de signe, il faut revenir en binaire. Admetons que nous voulons décrire le nombre 54 (positif) en binaire. Voici comment il se décrit : %00110110, ou encore #36. Si nous travaillons en octets signé, le bit de poids le plus fort étant bien à zéro, nous avons bien là une valeur positive.

[/fr][fr]


Pour représenter -54, il faut donc positionner le bit de signe à 1. On pourrai penser que c'est aussi simple que cela, et que -54 donne %10110110, ou encore #B6.
Mais non... -54 se décrit ainsi : %11001010 ou encore #CA.


Bon... Comment passer de 54 à -54 simplement ?
Et bien, on a inventé un codage, nomé "Complément vrai à 1" qui permet de représenter les nombres négatifs.
Pour cela, il suffit de complémenter (inverser) les bits de notre nombre, et ensuite de lui ajouter 1. Voici le détail :

54 : %00110110 #36
Complément : %11001001 #C9 (on inverse tous les bits)
Ajout 1 : +%00000001 #01
Résultat : %11001010 #CA

Pourquoi avoir ajouté 1 ? Et bien, dans le traitement des nombres positifs/négatifs, il y a un cas particulier à traiter.


Le cas du zéro. Le zéro étant considéré comme positif, il est absurde de vouloir le représenter avec un signe négatif. Donc, comme les nombres positifs varient de 0 à 127, les nombres négatifs ne varient pas de 0 à -127, mais de -1 à -128. D'ou l'ajout de 1 pour la conversion nombre positif->négatif.
Maintenant, faisons l'opération inverse : convertif -54 en +54...

-54 : %11001010 #CA
Complément : %00110101 #35 (on inverse tous les bits)
Ajout 1 : +%00000001 #01
Résultat : %00110110 #36

On retrouve donc bien notre 54 !


La méthode du complément vrai à 1 permet donc de passer de nombres positifs à négatifs, et inversement.
Elle fonctionne également pour les nombres de 16 bits, en utilisant le même principe, mais dans ce cas, c'est le bit 15 (bit de poids le plus fort) qui sert de signe.
Cette méthode permet de faire des soustractions très facilement : pour faire a - b, il suffit de faire a + (complément à 1 de b).

Bon, on s'arrête là pour Aujourd'hui... Ces bases sont importantes pour la suite, n'hésitez pas à faire quelques exemples de conversions, de calculs sur papier, et de contrôler vos résultat avec, par exemple, la calculatrice de Windows...



[/fr]

[en] 

We all know how to count up to ten, one hundred, one thousand, ten thoudand... and even up to billions.


But for this lesson, we will stop at a little bit more than 65,000. We'll see later why...

To understand what is about to come, you have to make the distinction between numbers and figures.
Basically, the figures are infinite and one million is a figure. But figures are a method of representing numbers. We describe numbers with ten figures, from 0 to 9. (To make the parallel with alphabet, we describe words with 26 letters, from A to Z.) When we're at 9, to describe the next number, one just has to add the figure 1 before the 0, which gives us ten. This method of representation is not the only one.
In fact, we represent numbers on a 10 basis. But why 10? Because we use 10 figures. Now, let's imagine that these are the only two figures we can use. The 0 and the 1. Then, one says that he's on a 2 basis, because there are just two figures existing.


To count up to 1, no problem: 0 then 1. And now, two? Well, since we don't have any figure available, we wil do as we do for the 10 basis. We add one figure before the first one. So our two will be represented by 10.


And three? Well, in 10 basis, it will be represented by 11. In fact, we rise up the figure on the far right. We it is up to its maximum, it goes back to zero (the first figure from every basis is zero) and we rise up the next figure on the left. If it is also up to its maximum, one repeats the operation.
Here is an example of representation of the first sixteen figures in the two basis:

 
I voluntarily aligned the two basis values on the right in order to allow to see better that the figure on the far right is always increased, and that next it's the figure on the left and so on. I also stopped at 15, and we'll see later why.

[/en][en]


But remind that sixteen is represented this way: 10000 (five figures!)

Some vocabulary to remind: a ten basis is called a decimal, or commonly the decimal. The two basis is called binary basis or the binary


A group of 8 bits is called an byte. But what is the point of counting in binary? Well, basically, the Z80 processor can only count in binary. And why is that? Because the information they deal with is represented under the form of electric tensions, so they can only distinguish two kind of information: if there is a tension or not...


So you can compare a processor to a lamp bulb which is switched on or not. When switched off it's 0, when switched on it's 1.


We created our first machine code program: lighting on a lamp.
Seriously now, this is the basic principal of a processor: treating the information in binary.

But how do they treat large numbers? Well, they add numbers
And this is when we presend the "bit". What? What is this? Well, rather than talking about figures (from 0 to 9), we talk about bits to represent the figures in binary.


So, a bit is the element which takes the value 0 or 1 and is used to represent numbers in binary. And our good old Z80 being an 8 bits processors, this means that he can deal with numbers represented by a group of eight bits.

[/en][en]


So, how far is an 8 bits number? Rather than trying to write all the possibilities in order to obtain the maximum (represented by 11111111), there are mathematical formulas to know the maximal number represented by figures on a certain basis. If you come back to decimal, it's easy to know that we're representing numbers from zero to nine with one figure (that is ten different numbers), from zero to ninety nine with two figures (that is a hundred different numbers) and so on. The mathematical formula for the decimal is: 10^number_of_figures


If we use four figures, we can represent: 10^4 = ten thoudans numbers, from zero to nine thousand nine hundred and ninety nine.


And the formula is ok with every basis:
basis^number_of_figures
For our Z80, we work in binary with 8 figures (sorry, bits). And the formula is: 2^8=two hundred and fifty six values from zero to two hundred and fifty five.
But cannot the Z80 deal with 16 bits numbers? Well, yes, but we'll see that later.
We can just notice that a 16 bits number will have a maximum value of 65536 (2^16), that is from 0 to 65535, wich binary representation is 1111111111111111 (sixteen 1). Not very practical, isn't it? Fortunately, there's another way to represent figures: the hexadecimal


What the heck is this ?
The hexadecimal is the name used for the 16 basis, which is represented with figures (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) and letters (A, B, C, D, E, F.)
So, it gives us : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
So we'll write:

[/en][en]

And the sixteen? Well, as for every basis, it's represented this way: 10.
If extended, one can notice that there is a direct relation between binary and hexadecimal: a four bits group will always be represented the same way as hexadecimal
Plus, as 4 bits can represented up to 16 numbers, it's the same as an hexadecimal figure!

Another example:

 
To make it simplier, we add on the left the non significative zeros and split it under 4 bits group (that is an hexa figure...

[/en][en]

As one can see hexadecimal and binary are quite similar. So, it's easy to make hexadecimal<->binary conversions. Much more anyway than decimal<->binary.

A small example:
convert:

11011001 (binary) in hexadecimal ...

Well, 1101 is D in hexa and 1001 9, so in our example, 11011001 is D9 in hexa!

Another one. Convert: 11110011 (binary) in hexadecimal...
1111 = F, 0011 = 3, or F3!

Important to note that hexadecimal codes (better to say code than figures, because these codes mix figures and letters), can be confused with text. That is why, generally, we add a symbol before an hexadecimal number to underline the fact that we are talking about a number and note a name!
This symbol is generally # or the commercial "and" (&). So our two examples are represented this way: #D9 or &D9 and #F3 or &F3.


In binary too, we use a character to make the difference between a decimal and binary number. This character is the percent (%). So, it's %11011001 and %11110011.

No much complicated, is it? Ok, let's make it a little bit more tricky.


How can we convert binary to decimal?
To convert a binary value in decimal, it's quite simple. Indeed, as every binary figure can only have the value 0 or 1, You just have to give some weight to every bit of our binary number. This weight will be stronger every time we will go through left figures.


So, if the weight of the far right figure is equal to one, the weight of the figure on its left is 2, 4, 8, 16... So:

Number of the bit 7 6 5 4 3 2 1 0
Weight 128 64 32 16 8 4 2 1

[/en][en]


Generally, the far right bit begins on 0, because 2^0=1 (weight) and so on... (2^7=128)
The bit on the far right is also called low weight bit. The bit on the far left is called high weight bit. Let's avec an example with the binary number %10110010.

Number of the bit 7 6 5 4 3 2 1 0
Weight 128 64 32 16 8 4 2 1
Value of the bit 1 0 1 1 0 0 1 0

One only needs to add the weight of the bits different from 0, that is:
128 + 32 + 16 + 2, which gives 178 in decimal!
Easy? Well, let's try the other way around...
Let's take another number. 201 in decimal for example. How to convert 201 in binary? One just has to decompose 201 in its ^2, that is the weights of a binary number
201 being superior to 128, the bit 7 is on 1. Then one substracts 128 to our number, that is 201-128=73. And then do it again on every ^2, up to 1 (2^0)


So, back from the beginning:

201 - 128 = 73 ( 201 contains 128, bit on 1 )
73 - 64 = 9 ( 73 contains 64, bit on 1 )
9 - 32 < 0 ( 9 does not contain 32, bit on 0 )
9 - 16 < 0 ( 9 does not contain 16, bit on 0 )
9 - 8 = 1 ( 9 contains 8, bit on 1 )
1 - 4 < 0 ( 1 does not contain 4, bit on 0 )
1 - 2 < 0 ( 1 does not contain 2, bit on 0 )
1 - 1 = 1 ( 1 contains 1, bit on 1 )

So, simple no? Well, yes, a bit complex but with some training, it's going to turn easy. On the decmal<->hexadecimal conversion it's a bit more complicated, so try first the decimal<->binary conversion, and then a binary<->hexadecimal one.

Now that we know how the processor represents numbers, how does it compute them?
Well, it's quite easy...

45
+87
-----
=132
For this: 5+7 = 12 (I put 2, keep 1), 4+8+1 (the one we kept)=13, that is 132.

In binary, it's the same.

Example:

%01001010
+%10111010
----------
%100000100

If one decomposes the operation, from right to left

- The first two figures, 0+0 = 0, easy.
- Then 1+1, in binary, it gives us 10, we keep 1.
- Then, 0+0=0 PLUS the 1 we kept.
- After that, 1+1 =0, keep 1, 0+1=1 PLUS the 1 we kept = 0 keep 1,
- Again, 1+1 =0, keep 1, 0+1=1 PLUS the 1 we kept = 0 keep 1,
- Again, 1+1 =0, keep 1, 0+1=1 PLUS the 1 we kept = 0 keep 1,
- 1+0 = 1 PLUS the figure we kept = 0, keep 1
- 0+1 = 1 PLUS the figure we kept = 0, keep 1
And we add the figure we kept to the final result

[/en][en]

Great !
Now the same on hexadecimal...
We take the same figures,

#4A
+#BA
----
#104

Easy with the conversion... But if you really do the operation, it gives us:
A+A = (ten + ten=twenty, that is #14), you put 4 and keep 1.
4+B = (four + eleven + the figure we kept = sixteen, = #10), we put 0 and keep 1.
That gives us at last #104.

Now that we know how to do some maths in binary and hexa, let's try to deal with signed numbers.
Yes, for the moment, we only studied positive numbers. But how do we deal with negative ones?
By adding '-'. Yes, but we're dealing with a processor which deals with 8 or 16 bits numbers and which has to know the sign of a number on an easy basis. This is why the signed numbers were invented.
A non signed number, say an 8 bits one, has its value represented by these 8 bits. A signed byte a byte is 8 bits long), has a value represented by 7 bits only. What about the 8th one? It gives us the sign.


Evidently, by erasing a bit for the value, one can only go from 0 to 127. And with the sign?
To understand the functionning of the sign bit, let's go back to binary. Let's admit that we want to describe the number 54 (positive) in binary. This is how it is described: %00110110, or #36. If we take the signe bytes, the stronget bit being at 0, we have a positive value.


To represent -54, we have to put the sign bit on 1. We might think that it is that simple and that -54 gives us %10110110, or #B6.
But no.... - 54 is described like this: %11001010 or #CA.
So, how to go from 54 to -54 in a simple way?
Well, a coding was invented, named "1 True complement" which allows negative numbers.
For this, we just have to inverse the bits of our numbers and add 1. Here's the detail:

54 : %00110110 #36
Complement : %11001001 #C9 (we inverse every bits)
Adding 1 : +%00000001 #01
Result : %11001010 #CA

[/en][en]

Why adding 1? Well, treating positive/negative numbers, there's a particular case to deal with.
The zero. The zero is considered as positive, it is absurd to try to represent it as negative. So, as the positive numbers go from 0 to 127, the negative ones go from -1 to -128. That is why 1 is added for the positive->negative conversion.
Now, let's do the other operation: convert -54 in +54...

-54 : %11001010 #CA
Complement : %00110101 #35
Addingt 1 : +%00000001 #01
Result : %00110110 #36

So, we do get our 54!


This method allows to go from positive to negative, and the other way back too.
It also works with 16 bits numbers, by using the same principle, but then it's the bit 15 which gives the sign.

OK. That's enough for now... Theses bases are impotant for the next lessons. So, do practice and control your results with the Windows calculator.

[/en]

  Voir cet article au format PDF Imprimer cet article

* Donathon 2018 *

340 €

 

 

 

 En savoir plus

RECHERCHE
Chat
 Smiles  Loading...
Connexion
Nom d'utilisateur :

Mot de passe :

Se souvenir de moi



Mot de passe oublié?

Inscrivez-vous!
EN LIGNE
9 utilisateur(s) en ligne (1utilisateur(s) en ligne sur Les articles Amstrad)

Membres: 1
Invités : 8

Golem13, plus...
Musiques CPC

Lecteur MP3
CPC-Scene Radio

 

 

ROLAND RADIO

 

Informations
________________________________

Suivre Amstrad.eu

________________________________

Autres Créations web

________________________________

 

Declaration CNIL : 1005884

Association : 0540200002843

Charte

Avertissements

Plan du site

Carte de France des membres

 

 

 

Facebook.

Twitter.

RSS forum.

RSS News.

Contact.

 

Gaston-Phoebus.com

Amstrad.eu

untour.fr

Cathydeco.com

Higoogle

Harloup.fr

** Faire un don **

 

Conception Phenix © 2000 - 2014