Pourquoi utiliser d'autres bases de nombres lors de la programmation

Mes collègues et moi-même avons bien réfléchi à la question de savoir pourquoi quelqu'un se mettrait en quatre pour programmer des numéros dans une base autre que la base 10.

J'ai suggéré que vous pourriez peut-être optimiser des équations plus longues en plaçant les variables dans la base correcte avec laquelle vous travaillez (par exemple, si vous n'avez que des ensembles de 5 de quelque chose sans reste, vous pouvez utiliser la base 5), mais je ne suis pas sûr si c'est vrai.

Des pensées?

La raison habituelle pour écrire des nombres, dans le code, en dehors de la base 10, c'est parce que vous êtes en train de bidouiller.

Pour prendre un exemple en C (parce que si C est bon pour quelque chose, c'est bon pour le twiddling), disons qu'un formatage de bas niveau code un octet à 2 bits et un nombre à 6 bits dans un octet xx yyyyyy::

main() {
    unsigned char codevalue = 0x94; // 10 010100
    printf("x=%d, y=%d\n", (codevalue & 0xc0) >> 6, (codevalue & 0x3f));
}

produit

x=2, y=20

Dans un tel cas, écrire les constantes en hexadécimal est moins déroutant que de les écrire en décimal, car un chiffre hexadécimal correspond parfaitement à quatre bits (un demi-octet; un "petit") et deux à un octet: le nombre 0x3fa tous les bits. dans le petit quartet et deux bits dans le petit haut.

Vous pouvez aussi écrire cette seconde ligne en octal:

printf("x=%d, y=%d\n", (codevalue & 0300) >> 6, (codevalue & 077));

Ici, chaque chiffre correspond à un bloc de trois bits. Certaines personnes trouvent cela plus facile de penser, même si je pense que c'est assez rare de nos jours.

La principale raison pour laquelle j'utilise différentes bases, c'est lorsque je me soucie des bits.

C'est beaucoup plus facile à lire

int mask=0xFF;
byte bottom_byte = value & mask;

que

int mask=255;
byte bottom_byte = value & mask;

Ou imaginez quelque chose de plus complexe

int mask=0xFF00FF00;
int top_bytes_by_word = value & mask;

par rapport à

int mask=4278255360; //can you say magic number!? 
int top_bytes_by_word = value & mask;

C’est très clair ici ce que l’intention veut faire avec les exemples hex car hex est fondamentalement juste une forme plus compacte de binaire ... En revanche, la base 10 (ce que nous utilisons) ne mappe pas aussi bien en binaire.

0xFF = b11111111 = 255
0xFFFF = b1111111111111111 = 65536
0xF0F0 = b1111000011110000 = 61680

Il existe également d'autres bases que vous pouvez utiliser dans certaines langues. Vous ne trouverez que très peu d'utilisation de bases autres que binaires, hexadécimales et décimales. Certaines personnes étranges utilisent encore l'octal, mais c'est à peu près la plus ésotérique que vous verrez dans un programme sensé.

Comme vous le savez probablement, les ordinateurs sont basés sur le binaire - il s’agit de la base 2.

Il est facile de convertir entre les bases 2 et 4, 8 et 16 (et des multiples similaires de 2), et le fait de garder cette traduction dans le code source peut rendre le travail sur les nombres beaucoup plus facile à raisonner.

Pour les langages de bas niveau tels que Assembly et C, ceci peut être traduit directement en opérations de processeur (décalage de bits pour la division et la multiplication, par exemple), ce qui signifie que l'utilisation de ces bases de nombres aboutit à un code beaucoup plus rapide.

De plus, toutes les opérations ne sont pas des opérations numériques - il existe des cartes de bits dans lesquelles vous devez manipuler les bits directement - l'utilisation d'une base 2 ou de l'un de ses multiples facilite grandement les opérations.

Si vous souhaitez en savoir plus, je vous recommande de lire Code by Charles Petzold .

Peut-être que vous écriviez un jeu qui simule l'économie d'une civilisation ancienne utilisant un système de base 12.

En dehors des programmes hautement spécialisés, il est assez rare d’utiliser des bases autres que 10, 16 ou 2.

La base 16 (hexadécimale) est utile car la plage complète d'un octet (0-255) peut être représentée par deux chiffres (0x00-0xFF), ce qui facilite grandement l'utilisation de dumps hexadécimaux bruts ou de données binaires. Le format hexadécimal est également utile lorsque vous utilisez des masques de bits avec des opérateurs au niveau du bit, car la correspondance de deux chiffres avec un octet facilite la lisibilité.

Plus rarement, la base 2 (binaire) peut également être utilisée avec des opérations au niveau des bits, mais de nombreux langages de programmation ne prennent pas en charge les littéraux base-2 et, de toute façon, l'hexadécimal est beaucoup plus concis et lisible.

Base-8 (octal) est également parfois utilisé en raison d'autorisations de fichiers UNIX. En dehors de cela, il est assez rare d'utiliser des bases autres que 10 en dehors de contextes mathématiques hautement spécialisés.

La raison la plus courante pour utiliser d’autres bases est la facilité de conversion en base 2: il est simple de convertir un nombre en base 8 ou en base 16 en binaire sans utiliser de calculatrice en mémorisant un tableau court de huit ou seize. Nombres:

 0000 0     0001 1     0010 2     0011 3
 0100 4     0101 5     0110 6     0111 7

 1000 8     1001 9     1010 A     1011 B
 1100 C     1101 D     1110 E     1111 F

Cela ouvre plusieurs possibilités:

• Lorsqu'un nombre représente une composition de nombres binaires significatifs, vous pouvez déterminer les composants individuels sans ordinateur. Par exemple, si un nombre de 24 bits représente une couleur en RVB, il est simple de dire qu'il 0xFF00FFs'agit de magenta (rouge + bleu); la tâche est beaucoup plus difficile quand on vous présente16711935
• Lorsqu'un nombre représente un masque de bits, il est plus pratique de l'écrire sous la forme d'un nombre hexadécimal compact plutôt que d'un nombre binaire beaucoup plus long.
• Certaines architectures ont fait de leur mieux pour rendre leur code binaire facile à lire lorsqu'il est imprimé sous forme de nombres octaux. PDP-11 était l'un de ces systèmes: le bit le plus significatif vous permettait de distinguer les opérations 8 bits des opérations 16 bits; les deux derniers groupes octaux vous permettraient de dire les deux registres impliqués dans l'opération, etc. Je connaissais plusieurs personnes qui pouvaient lire le code binaire PDP-11 à l'écran sans désassembleur, mais ils avaient besoin que le code machine soit imprimé en système octal.

L'ordinateur (ou plus précisément le compilateur) ne se soucie pas vraiment de la base de nombres que vous utilisez dans votre code source. Les langages de programmation les plus couramment utilisés supportent directement les bases 8 (octal), 10 (décimal) et 16 (hexadécimal). Certains ont également un support direct pour les nombres de base 2 (binaires). Les langues spécialisées peuvent également prendre en charge d’autres bases de numéros. (Par "support direct", je veux dire qu'ils permettent la saisie de chiffres dans cette base sans recourir à des astuces mathématiques telles que le décalage de bits, la multiplication, la division, etc. dans le code source lui-même. Par exemple, C prend directement en charge la base 16 avec son code source.0xpréfixe numérique et le jeu de chiffres hexadécimaux régulier de 0123456789ABCDEF. Maintenant, de telles astuces peuvent être utiles pour rendre le nombre plus facile à comprendre dans le contexte, mais tant que vous pouvez exprimer le même nombre sans eux, cela ne sert à rien - ou pas - de le rendre pratique.)

En fin de compte, cependant, c'est sans importance. Disons que vous avez une déclaration comme celle-ci:

int n = 10;

L'intention est de créer une variable entière et de l'initialiser avec le nombre décimal 10. Que voit l'ordinateur?

i  n  t     n     =     1  0  ;
69 6e 74 20 6e 20 3d 20 31 30 3b (ASCII, hex)

Le compilateur va tokeniser cela et se rendre compte que vous déclarez une variable de type intavec le nom net lui attribuer une valeur initiale. Mais quelle est cette valeur?

Pour l'ordinateur, et en ignorant les problèmes de classement et d'alignement d'octets, l'entrée de la valeur initiale de la variable est 0x31 0x30. Cela signifie-t-il que la valeur initiale est 0x3130 (12592 en base 10)? Bien sûr que non. L'analyseur de langage doit continuer à lire le fichier dans le codage de caractères utilisé. Il doit donc être 1 0suivi d'un terminateur d'instruction. Etant donné que dans cette langue, la base 10 est supposée, cela se lit (en arrière) comme "0 unités, 1 dizaines, fin". C'est-à-dire une valeur de 10 décimales.

Si nous avons spécifié une valeur en hexadécimal et que notre langage utilise 0xpour spécifier que la valeur suivante est en hexadécimal, nous obtenons ce qui suit:

i  n  t     n     =     0  x  1  0  ;
69 6e 74 20 6e 20 3d 20 30 78 31 30 3b (ASCII, hex)

Le compilateur voit 0x(0x30 0x78) et reconnaît cela comme préfixe base 16, recherche un numéro valide base 16 après celui-ci. Jusqu'à la fin de commande , il lit 10. Cela se traduit par 0 "uns", 1 "sixteens", ce qui correspond à 16 en base 10. Ou 00010000 en base 2. Ou comme vous préférez le représenter.

Dans les deux cas, et en ignorant les optimisations pour des raisons de simplicité, le compilateur alloue suffisamment de stockage pour contenir la valeur d'une intvariable de type et y place la valeur lue à partir du code source dans une sorte de variable de conservation temporaire. Il écrit ensuite (probablement beaucoup plus tard) les valeurs binaires résultantes dans le fichier de code objet.

Comme vous le voyez, la façon dont vous écrivez des valeurs numériques dans le code source est totalement sans conséquence. Cela peut avoir un effet très léger sur les temps de compilation, mais j'imagine que (encore une fois, en ignorant de telles optimisations telles que la mise en cache sur le disque par le système d'exploitation), des turbulences aléatoires autour des plateaux en rotation, les temps d'accès au disque, les collisions de bus de données , etc., ont un effet beaucoup plus grand.

En bout de ligne: ne vous inquiétez pas pour ça. Écrivez les nombres dans une base compatible avec votre langage de programmation et expliquant comment le nombre sera utilisé et / ou lu. Vous avez passé beaucoup plus de temps à lire cette réponse que vous ne pourrez jamais récupérer en temps de compilation en sachant quelle base de nombres utiliser dans le code source. ;)

pourquoi quelqu'un se mettrait en quatre pour programmer des numéros dans une base autre que la base 10.

Voici quelques raisons qui ne sont pas déjà apparues ...

x00 - Les API de certains systèmes d'exploitation et périphériques matériels s'attendent à ce que les arguments soient au format hexadécimal / binaire. Lorsque vous codez pour de telles API, il est plus facile d'utiliser les nombres dans le même format que celui attendu par l'API au lieu de le convertir entre différentes bases. Par exemple, envoyer un octet de fin de message à un serveur ou envoyer un message pour fermer une connexion à un canal de communication.

x01 - Vous pouvez souhaiter que votre application représente des caractères non disponibles sur certains claviers, tels que le symbole de copyright (\ u00a9).

x02 - Pour que certaines constantes / littéraux persistent (visuellement) dans différents paramètres de culture, en particulier lorsque le code source / les fichiers sont déplacés entre les développeurs avec des paramètres locaux différents.

x03 - Pour rendre leur code complexe et confus - La bonne chose est que C # ne supporte pas les constantes octales!

Le problème clé est de représenter un mot de la taille d’un ordinateur de manière raisonnable. Le 6502 était un processeur 8 bits. Le 4004 était un processeur 4 bits.

Lorsqu'il s'agit d'un nombre de 4 ou 8 bits, cela fonctionne bien. Un nombre de 4 bits est un caractère hexadécimal unique. Un nombre de 8 bits (un octet) est deux chiffres hexadécimaux. Les systèmes qui ont une puissance de 2 mots sont la norme la plus répandue aujourd'hui - 16 bits, 32 bits, 64 bits. Tous ces éléments se divisent bien par 4 pour une représentation hexadécimale.

Octal (base 8) a été utilisé dans des systèmes où la taille des mots était de 12, 24 ou 36. PDP8, IBM Mainframe et ICL 1900 d’anciens jours les utilisaient. Ces mots ont été plus facilement représentés en utilisant des octets plutôt qu’une plage limitée d’hexadécimaux (oui, ils se divisent également en 4 également).

Apparemment, la numérotation en base 8 permettait également de réaliser des économies. Représentant 12 bits en BCD, le premier chiffre ne peut être que de 0 à 4 mais les deuxième, troisième et quatrième peuvent être de 0 à 9. Si cela a été fait en hexadécimal, l’un a 3 caractères hexadécimaux, mais chacun a 16 valeurs possibles. Il était moins coûteux de produire un tube Nixie contenant uniquement 0-7 unités que celui contenant 0-9 (avec une logique supplémentaire pour BCD) ou 0-F pour hexadécimal.

On voit encore aujourd'hui octal avec des permissions de fichiers unix (755, 644) où propriétaire, groupe et monde ont chacun 3 bits représentant les permissions.

Dans le monde des mathématiques, on fait parfois des choses étranges avec des bases différentes. Par exemple, une séquence de Goodstein faible du projet euler 396 ... ou quelque chose de plus simple avec des nombres palindromiques . Il existe la propriété d’un nombre en base N qu’un nombre qui est un multiple de N-1 aura ses chiffres jusqu’à un multiple de N-1 . De plus, si N - 1 est un carré parfait, cette propriété existe également pour sqrt ( N - 1 ). Cela a des applications dans certains problèmes mathématiques.

Dans le secteur financier, il existe un système d’identification qui est effectivement la base 36 . Il utilise les chiffres 0 à 9 et les lettres BZ pour représenter les chiffres valant de 0 à 35. Il saute les voyelles pour empêcher la génération de noms désagréables.

Ce n'est pas parfait, cependant. Il fut un temps où une entreprise malheureuse avait l'identifiant B000BZ.

Raison n ° 1: tous les nombres au niveau du circuit sont représentés en base 2 (interrupteur électrique activé ou désactivé). Raison n ° 2: parce qu’à un niveau supérieur aux circuits réels, les bits sont regroupés en octets et les octets peuvent facilement être représentés sous forme de deux chiffres hexadécimaux, alors qu’il faudrait trois chiffres décimaux (et une validation) pour représenter toutes les valeurs possibles du paramètre. octet.

Ainsi, si vous travaillez à ces niveaux (ou les approchons, dans certains environnements gérés), il est plus facile de travailler en binaire ou en hexadécimal que décimal. Les situations dans lesquelles vous feriez cela sont variées, mais ne sont généralement jamais des situations dans lesquelles vous avez simplement besoin de l'arithmétique de base.

Un domaine dans lequel les nombres de base 16 (hexadécimaux) sont très fréquemment utilisés est la spécification de la couleur, en particulier lors de l'utilisation de HTML / CSS pour le Web. Les couleurs que nous utilisons sur les écrans numériques sont spécifiées à l'aide d'une combinaison de 3 valeurs d'intensité pour 3 couleurs de base (RVB - rouge, vert, bleu) qui sont fusionnées pour créer l'une des 16 millions de couleurs affichables (en couleur 24 bits). ).

Par exemple, le vert d'intensité maximale dans l'hex serait 0x00ff00et 65280dans le nombre décimal. Maintenant, imaginez que vous essayez de mélanger "manuellement" une couleur dans votre tête qui a des parties égales de rouge et de bleu, disons à demi-intensité, pour créer un joli violet :) En hexa, cela serait écrit simplement comme 0x800080si sa valeur décimale était 8388736. Il est encore plus facile lorsque vous travaillez avec des nuances de gris - 50% de gris est 0x808080(hex) et 8421504(décimal), 75% est 0xC0C0C0et 12632256, et ainsi de suite.

L'utilisation de l'hex est beaucoup plus intuitive et quiconque est familiarisé avec cette utilisation de la couleur sera immédiatement en mesure de "deviner" la couleur simplement en regardant la valeur hexadécimale. Il est également beaucoup moins sujet aux erreurs si vous devez utiliser la même couleur plusieurs fois (ce qui est généralement le cas).

Vérifiez n'importe quelle page Web (et en particulier le CSS) pour une quantité folle d'utilisation d'hex: D

NOTE: En CSS, les valeurs hexadécimales sont écrites en utilisant un #préfixe, par exemple: #00ff00pour le vert, et est parfois raccourci à trois chiffres, comme #0f0pour le vert.

Pour certains algorithmes, la base 2 a plus de sens que toute autre chose. Par exemple, préféreriez-vous écrire une fonction pour parcourir un arbre binaire ou un arbre de 10 domaines?

Mais plus fréquemment, la base 2 est utilisée, car c’est ainsi que les ordinateurs représentent presque universellement leur nombre. Cela signifie que:

• de nombreuses opérations sont plus efficaces en base 2:
  • les puissances de multiplication, division et modulo de 2 sont beaucoup plus rapides que la division générale
  • les drapeaux et les petites valeurs peuvent être stockés, récupérés et manipulés plus efficacement sous forme de chiffres binaires d'un nombre plus grand.
• Les opérations qui lisent, écrivent et manipulent des fichiers de données et des flux de données réseau doivent traiter directement du fait qu'elles sont représentées sous forme de nombres binaires.

De plus, il existe toujours une application rare qui nécessite de manière inhérente une base impaire qui peut être ni 2 ni 10.

Honnêtement, c'est une préférence, si pour une raison quelconque vous avez une polydactylie et avez 11 doigts ou si vous aimez compter avec vos orteils, vous aimez donc travailler en base 20, c'est à vous de décider. Mais réalisez que sur un sujet d'universalité que la plupart d'entre nous qui traitons quotidiennement de bits et d'octets sera vraiment coché si nous obtenons quelque chose qui fait de la manipulation de bits en base 19.

RAISONS DE BASE x

Base 10 - Modèle de toutes nos affaires car nous avons 10 chiffres de comptage (les pieds sont étranges et malodorants, nous ne les utilisons pas).

Base 2 - Les ordinateurs l'utilisent pour les bits (marche / arrêt). Cela est lié aux niveaux de tension lisibles qui sont propagés par des portes / transistors / condensateurs.

Base 8 - Vieux, à l'époque où les ordinateurs n'étaient pas super énormes (ou à l'époque quand ils occupaient l'espace), c'était bon pour quelque chose ou autre (je n'aime pas ça du tout)

Base 16 - Idéal pour afficher les octets supérieurs et inférieurs d'un octet pour la manipulation de bits. Ceci est super utile dans le monde embarqué / fpga / hardware.

BASES NORMALES EN INFORMATIQUE

Pour aller avec préférence, je pourrais vous dire exactement comment "sur" une couleur est dans une valeur hexadécimale RVB qui m’a été donnée, cela peut donc être représenté dans un seul int dans le matériel et ensuite avec quelques décalages peut me être rendu easy-peasy, 1 couleur complexe = 1 point de données, idéal pour le traitement d'images de grande taille avec une mémoire limitée. Comparez cela à une représentation en base 10, vous pouvez les ajouter tous et les stocker dans un nombre, mais quel nombre correspond à quel nombre, ou peut-être que R correspond au temps 10000, G à 100, et B à son propre espace, ce qui représente de nombreuses opérations mathématiques , les multiplications coûtent généralement plus de cycles qu’une équipe, de sorte que votre prochain élément de données est déjà dans la file d’attente avant que vous n’ayez terminé, votre dernier élément étant en cours de traitement, oups, il n’est plus là.

Parfois, il est tout simplement préférable de travailler en base 2, 8 ou 16. Avec la plupart des machines, multiplier par 2 équivaut à changer un peu. Celles-ci sont super rapides. Même chose avec une division par 2.

Pour exposer encore plus loin l'idée d'un peu de tournage. Dans de nombreux environnements intégrés, j'ai souvent eu besoin d'accéder à un ensemble de lumières, de commutateurs ou à d'autres éléments mappés dans des registres.

Dans ce cas, attribuer un caractère entier, un octet ou un entier à chaque commutateur serait à la fois inefficace et ridicule, un commutateur ou une lampe a 2 positions - allumée et éteinte - pourquoi attribuer quelque chose ayant jusqu'à 256 positions ou 2 ^ 16 positions etc. Chaque lumière dans un tableau peut être un bit d’ajustement 8 ou 16 ou 32 ou 64 ou 128 (largeur de votre type de données) sur un seul mot / registre. L'efficacité de l'espace est nécessaire et plutôt bienvenue.

Utiliser tout ce qui est en base 2 ^ n dans la programmation pour la manipulation de données RVB, beaucoup de données de signal - GPS, audio, ASCII, etc. - est beaucoup plus simple en hexadécimal, binaire et octal puisque c'est ainsi qu'il est représenté dans la machine et que l'on peut plus facilement discerner ce qui est présenté et comment le manipuler.

UTILISER DES BASES STRANGE

Il n'y a pas d'efficacité à moins que vous ne codiez pour cela. Vous voulez la base 11, vous devez configurer un type de données et surcharger tous les opérateurs pour gérer sa représentation à l'utilisateur. Je ne vois aucune raison pour laquelle un système contenant 5 éléments et ne disposant que de multiples de 5 éléments devrait être converti en calcul de 5 éléments. Et de plus, vous feriez mieux de prier pour que celui qui a décidé d’écrire son code pour la base 271 l’ait bien documenté ou vous puissiez passer plus de temps à le comprendre que de créer de la base 271 car tous les éléments sont un multiple de 271.

À l'époque antique de l'informatique, nous avions un certain nombre d'écrans pouvant afficher les chiffres de 0 à 9, mais nous n'avions pas encore AF.

http://ad7zj.net/kd7lmo/images/ground_nixie_front.jpg en est un exemple ...

Octal convient parfaitement à ces affichages et est plus facile que binaire ou décimal.

Je suis surpris que toutes les autres réponses n'aient pas mentionné deux utilisations très courantes en informatique pour des bases alternatives:

1. Encodage : L’encodage Base64, par exemple, est extrêmement courant. Le codage interprète simplement une série d'octets comme un grand nombre binaire (base 2) et convertit ce nombre en un nombre Base64 représenté par des chiffres ASCII.

2. Compression : il est souvent souhaitable de représenter un nombre binaire, décimal ou hexadécimal dans une base plus grande afin de raccourcir la représentation. Par exemple, tous les raccourcisseurs tels que bit.ly le font. Ou vous pouvez le faire pour raccourcir un GUID pour l'utiliser dans une URL.

   - 821F6321-881B-4492-8F84-942186DF059B (base-16 guid) 
   becomes
   - RRIDHW463YD8YXX7MIDI (base-36)
   - 3UFmaWDjj9lifYyuT0 (base-62)