Système de numération.

Introduction.
Le système dans lequel nous exprimons les nombres que nous manipulons est un système de numération en base 10 dans lequel un chiffre a "un poids" différent suivant sa position.
Concrètement cela signifie que nous disposons de 10 chiffres (0, 1, 2, ..., 9) qui sont juxtaposés pour former un nombre mais que 123 et 213 ont des valeurs différentes.
Ainsi, 123 signifie 3 unités, 2 dizaines et 1 centaine. Et 213 signifie 3 unités, 1 dizaine et 2 centaines. Pourquoi, dizaine? Comme nous travaillons en base 10, nous ne disposons que de 10 chiffres et que nous ne pouvons dès lors exprimer avec un seul chiffre que les nombres compris entre 0 et 9. Le nombre entier succédant à 9 sera donc exprimé à l'aide de 2 chiffres: 10 où le chiffre 1 sera affecté d'un "poids" de dix. Pourquoi centaine? Parce que avec 2 chiffres, on ne peut exprimer que les nombres entiers compris entre 0 et 99. Le nombre suivant 99 sera donc exprimé avec 3 chiffres: 100 où le 1 sera affecté d'un poids de cent

Généralités.
D'une manière générale, le nombre anan-1...a2a1a0 si il est exprimé en base B ne pourra comporter que des chiffres ai compris entre 0 et B-1. Ainsi, en base 2, nous ne pourrons utiliser que les chiffres 0 et 1; en base 16, nous disposerons de 16 chiffres: 0, 1, .., 9 et nous continuerons avec les lettres A, B, C, D, E et F qui auront les valeurs dix , onze, douze, ..., quinze dans notre base usuelle.
Au nombre anan-1...a2a1 a0 sera associée la valeur
an * Bn + an-1 * Bn-1 + ... + a2 * B2 + a1 * B + a0 calculée en base 10.

Expression en base 10 d'un nombre exprimé en base B.
Comme nous disposons de calculateurs (ordinateur, calculette ou cerveau) habitués à travailler en base 10, tout changement de base de numération subira un passage obligé par la base 10. La seule exception à cette règle est pour les passages entre les bases 2 et 16.
Le calcul se fera à partir de la règle décrite ci-dessus:
(anan-1...a2a1 a0)B = (an * Bn + an-1 * Bn-1 + ... + a2 * B2 + a1 * B + a0 )10
Ce calcul peut aussi être exprimé sous la forme
((((an * B + an-1) * B +..) * B + a2) * B + a1) * B + a0
qui a l'avantage de ne faire intervenir que des additions et des multiplications d'entiers. Ceci un gage de vitesse et de précision.

 Expression en base B d'un nombre X exprimé en base 10.
De ((((an * B + an-1) * B +..) * B + a2) * B + a1) * B + a0 = X nous déduisons simplement que lorsqu'on divise (division cartésienne ou entière) X par B, on obtient un reste égal à a0 et un quotient entier égal à Y=((((an * B + an-1) * B +..) * B + a2) * B + a1)
De même, en effectuant la division entière de Y par B , nous obtenons un reste égal à a1
et un quotient égal à Z=(((an * B + an-1) * B +..) * B + a2
En opérant des divisions successives, nous obtenons tous les chiffres du nombre (on arrête les divisions lorsque le quotient obtenu est nul).

Passages entre les bases 2 et 16.
Dans la base 2, les seuls chiffres disponibles sont 0 et 1.
Dans la base 16, les chiffres disponibles sont:

En base 16

En base 2

En base 10

0

0000

0

1

0001

1

2

0010

2

3

0011

3

4

0100

4

5

0101

5

6

0110

6

7

0111

7

8

1000

8

9

1001

9

A

1010

10

B

1011

11

C

1100

12

D

1101

13

E

1110

14

F

1111

15

Ce tableau montre tout l'intérêt de la base 16. Comme exprimer des nombres en base 2 est particulièrement fastidieux et sujet à erreur, l'idée a été de les regrouper par 4 et de convertir chaque groupe en 1 chiffre hexadécimal. Les chiffres de la base 16 permettent en effet de trouver le chiffre correspondant à chaque groupe de 4 chiffres binaires.

Le passage de la base 2 à la base 16 se fera donc par regroupement de 4 chiffres binaires consécutifs (en partant de la droite et en allant vers la gauche) et de la traduction en base 16 à l'aide du tableau décrit ci-dessus.
Exemple: (111011001)2 = 0001 1101 1001 = (1D9)16

Le passage de la base 16 à la base 2 se fera par traduction d'un chiffre hexadécimal en 4 chiffres binaires à l'aide du tableau décrit ci-dessus.
Exemple: (3AF)16 = 0011 1010 1111 = (1110101111)2

L'algorithme...
L'algorithme décrit ci-dessous demande à l'utilisateur un nombre N exprimé dans la base Base et l'exprime dans la base NewBase.
En clair, un nombre tel que 123, exprimé en base 10 peut être transformé en son équivalent hexadécimal, binaire ou autre.

L'ordinateur calculant en base 10, la première tâche est de ramener N dans la base 10. Pour ce faire, nous allons exploiter le fait que nous travaillons avec une numération de position, à savoir qu'en base 10

12345 = 1 * 104 + 2 * 103 + 3 * 102 + 4 * 101 + 5 * 100

Chaque chiffre est donc multiplié par la base élevée à la puissance adéquate. Dans notre algorithme, c'est la fonction Base10 qui se chargera de la transformation de N en base 10.
Le passage à la base NewBase se fait de manière inverse en procédant à des divisions successives du nombre exprimé en base 10.
Mais un exemple rendra les choses plus claires.
Prenons 756 exprimé en base 9 et que nous désirons écrire en base 8.
(1) Vérifions d'abord que le nombre 756 est un nombre "valide" dans la base 9. Pour ce faire, regardons si chaque chiffre est "acceptable" pour cette base. En base 9, il y a 9 chiffres: 0, 1, 2, 3, 4, 5, 6, 7 et 8. Dans l'algorithme décrit ci-dessous, c'est la fonction Verifie qui se charge de cette vérification.
(2) Exprimons 756 en base 10:
7569 = 7 * 92 + 5 * 91 + 6 * 90 = (7 * 9 + 5) * 9 + 6 = 61810
et le passage à la base 10 se fera par des multiplications/additions successives plutôt qu'avec des exponentiations moins rapides et moins précises.
(3) La transformation en base 8 se fera par des divisions successives:
61810 = 2 + 8 * (5 + 8 * (1 + 8 * 1)) = 1 * 83 + 1 * 82 + 5 * 81 + 2 * 80 = 11528 
chaîne: Chiffres, N
entier: Base, NBase


Fonction Verifie(St,Base) Vérifie si le nombre est valable
 paramètre:  St: chaîne
             Base : entier
 à valeur: booléen


booléen: Verif
entier: i, Cpt


Cpt <--  0
pour i de 1 à|St| faire
   si Pos(Sti, Chiffres) > Base alors Cpt <-- Cpt+1 Cpt compte le nombre de chiffres non valables
   fsi
fpour
si Cpt>0 alors Verif <-- faux
sinon Verif <-- vrai
fsi
Résultat (Verif)


Fonction Majuscules(St)   Met le nombre en majuscules (intéressant pour les bases supérieures à 10)
 paramètre: St: chaîne
 à valeur: chaîne


entier: i


pour i de 1 à |St| faire
  si (Sti > "a") et (Sti  < "z") alors Sti <-- UpCase(Sti)UpCase est une fonction Pascal
  fsi
fpour
Résultat (St)


Fonction Base10(St, Base)     Transforme le nombre en base 10
 paramètre:  St: chaîne
             Base: entier
 à valeur: entier


 entier: i, B10


B10 <-- 0
pour i de 1 à |St| faire
 B10 <-- B10 * Base + Pos(Sti,Chiffres) - 1
fpour
Résultat(B10)


Fonction NewBase(N, Base)    Transforme le nombre de base 10 en NewBase
 paramètre: N, Base: entier
 à valeur: chaîne


entier i
chaîne: B


B <-- ""
tant que NOT (N = 0) faire
 i <-- N mod Base
 B <-- Chiffresi+1 + B
 N <-- N \ Base
ftant
Résultat(B)


Chiffres <-- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
écrire  "Introduisez le nombre (0 pour arrêter):"
lire N       Le nombre est lu sous forme de chaîne (pour les bases > 10, on utilise les chiffres A, B, ...)
tant que NOT (N="0") faire
 N <-- Majuscules(N)
 écrire "Dans quelle base est-il exprimé: "
 lire Base
 si NOT Verifie(N,Base) alors écrire "Le nombre n'est pas correct!"
 sinon écrire "Dans quelle base faut-il l'exprimer: "
       lire NBase
       écrire N," en base ",Base, " = ", NewBase(Base10(N,Base),NBase), " en base ",NBase
 fsi
 écrire "Introduisez le nombre (0 pour arrêter): "
 lire N
ftant

PROGRAM Chgt_Base;

VAR Chiffres, N : STRING;
    Base, NBase : BYTE;

FUNCTION Verifie(St:STRING;Base:BYTE):BOOLEAN;
VAR i, Cpt : BYTE;
BEGIN
Cpt:=0;
FOR i:=1 TO LENGTH(St) DO
  IF POS(St[i],Chiffres)>Base THEN INC(Cpt);
IF Cpt>0 THEN Verifie:=FALSE
ELSE Verifie:=TRUE
END;

FUNCTION Majuscules(St:STRING):STRING;
VAR i : BYTE;
BEGIN
FOR i:=1 TO LENGTH(St) DO
  IF (St[i]>='a') AND (St[i]<='z') THEN St[i]:=UPCASE(St[i]);
Majuscules:=St
END;

FUNCTION Base10(St:STRING;Base:BYTE):LONGINT;
VAR i   : BYTE;
    B10 : LONGINT;
BEGIN
B10:=0;
FOR i:=1 TO LENGTH(St) DO
  B10:=B10*Base+POS(St[i],Chiffres)-1;
Base10:=B10
END;

FUNCTION NewBase(N:LONGINT;Base:BYTE):STRING;
VAR i : BYTE;
    B : STRING;
BEGIN
B:='';
WHILE NOT (N=0) DO
  BEGIN
  i:=N MOD Base;
  B:=Chiffres[i+1]+B;
  N:=N DIV Base
  END;
NewBase:=B;
END;

BEGIN
Chiffres:='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
WRITE('Introduisez le nombre (0 pour arrêter):');
READLN(N);
WHILE NOT (N='0') DO
  BEGIN
  N:=Majuscules(N);
  WRITE('Dans quelle base est-il exprimé ');
  READLN(Base);
  IF NOT Verifie(N,Base) THEN WRITELN('Le nombre n''est pas correct!')
  ELSE BEGIN
       WRITE('Dans quelle base faut-il l''exprimer: ');
       READLN(NBase);
       WRITELN(N,' en base ',Base, ' = ', NewBase(Base10(N,Base),NBase), ' en base ',NBase);
       END;
  WRITE('Introduisez le nombre (0 pour arrêter):');
  READLN(N);
  END;
END.

Page d'accueil.