[MUSIQUE] [MUSIQUE] Nous allons maintenant étudier les types prédéfinis numériques. Il y a deux catégories de types numériques prédéfinis, qui correspondent en mathématiques d'une part aux entiers naturels, et d'autre part aux réels. Il faut tenir compte du fait que ces représentations restent cependant des approximations par rapport à ce que vous connaissez en mathématiques. Pourquoi des approximations? D'une part parce qu'on va simplement définir un sous-ensemble des valeurs de l'ensemble des entiers, et un sous-ensemble des valeurs des réels. Et puis, en particulier pour les réels, il va y avoir des questions de précision. Les chiffres après la virgule, on va travailler avec une précision qui va être limitée, ce qui fait que dans les calculs on va souvent travailler avec des valeurs proches plutôt qu'avec des valeurs exactes, ce qui pourra avoir des résultats, des conséquences en particulier sur des erreurs d'arrondis quand on accumule des calculs sur des variables de type réel. Ces caractéristiques d'approximation, elles sont importantes parce qu'elles font la différence entre les vrais entiers naturels, les vrais réels et leur représentation en informatique. Pour ce qui est des entiers, il existe quatre types. Le type qui s'appelle Byte, le type qui s'appelle Short, le type qui s'appelle Int et le type qui s'appelle Long. Byte avec une majuscule, Short avec une majuscule, Int avec une majuscule et Long avec une majuscule. Ces quatre termes font partie du vocabulaire du langage Scala, et ils désignent chacun un des quatre types d'entiers qui existent en Scala. Qu'est-ce qui va faire la différence entre ces quatre types? Tout simplement la taille mémoire qui va être utilisée pour stocker les valeurs de ces entiers. Pour un Byte, on utilisera un octet, pour un Short on en utilisera deux, pour un Int on en utilisera 4, et pour un Long on en utilisera 8. La conséquence, elle est sur la taille de l'intervalle que les valeurs vont pouvoir prendre. Intuitivement, vous vous doutez bien que plus on va avoir un espace mémoire large, plus on va pouvoir avoir un intervalle qui va lui aussi être large. C'est exactement la conséquence qu'on va avoir. Le Byte va représenter un intervalle des entiers plus petit que le Short, qui lui-même va représenter un intervalle plus petit que les Int, qui lui-même va représenter un intervalle plus petit que le Long. Pour vous donner un exemple, sans rentrer vraiment dans le détail de la codification des valeurs entières, si on prend l'exemple des Byte, les valeurs vont être codées sur un octet, c'est-à-dire sur 8 bits, huit positions binaires. [SON] On va avoir des nombres binaires de huit chiffres. Chaque chiffre va pouvoir prendre soit la valeur 0, soit la valeur 1, donc en binaire ou en base 2. Dans la codification qu'on va avoir ici pour les Byte, le premier bit va être utilisé pour représenter le signe plus ou moins avec le 0 ou avec le 1. Et les sept bits restants vont être utilisés pour représenter la valeur numérique de l'entier. Simplement, au lieu d'être codé en base 10 comme on utilise les valeurs entières, il va être codé en binaire, en base 2. Si bien qu'ici, on dispose de sept positions. Le nombre de valeurs binaires qu'on peut calculer, ça va être 2 puissance 7 c'est-à-dire 128. Donc on va pouvoir représenter 128 valeurs entières avec un Byte. Plus le signe, on va donc pouvoir aller de moins 128 jusqu'à plus 127. Pourquoi 127 et pas plus 128? Tout simplement parce que l'intervalle a le 0, et le 0 fait partie des chiffres entiers positifs. On a le même mécanisme pour les Short, pour les Int, pour les Long. Simplement, ici vous comprenez que la taille mémoire qu'on va pouvoir utiliser va être beaucoup plus longue, et du coup, le nombre de valeurs entières qui vont pouvoir être représentées va être là aussi beaucoup plus grand. Pourquoi dispose-t-on de quatre types différents? C'est principalement pour des raisons d'optimisation d'occupation en mémoire. L'idée est de choisir en fonction de l'ordre de grandeur des valeurs de la variable que vous allez choisir, de choisir le type qui va être le plus approprié, de façon à optimiser au mieux l'occupation en mémoire que vous allez avoir pour vos variables. Ensuite, pour un type, ce qu'on doit définir c'est la façon de représenter les valeurs. Pour les valeurs entières, c'est relativement simple, ça correspond exactement à ce que vous connaissez traditionnellement. C'est-à-dire que si je veux représenter la valeur entière 123, je vais simplement écrire à la suite les chiffres 1, 2 et 3. Je peux aussi faire précéder la valeur du signe plus ou du signe moins. Par défaut, 123, le plus est sous-entendu : plus 123 et moins 123. La façon de représenter des valeurs entières, quel que soit le type de valeur entière que vous avez choisi, est celui que vous connaissez traditionnellement pour représenter les entiers naturels. Par défaut, ces valeurs, elles ont un type, et le type par défaut qui va être attribué par Scala c'est le type Int. Si vous voulez représenter ces valeurs en type Long, c'est-à-dire sur une zone mémoire plus longue, vous pouvez le faire en ajoutant tout de suite à la suite de la valeur numérique la lettre l, qui symbolise le l du Long, et qui représentera donc cette valeur sous forme d'une codification Long. Évidemment, la valeur 123 entière ou la valeur 123 en Long, ça reste toujours la même valeur. Ce qui va changer c'est simplement en mémoire interne la façon dont la codification va se faire. Elle va se faire sur quatre octets pour un Int ; elle va se faire sur huit octets pour un Long. Il est bien évident que les quatre types d'entiers qui existent sont compatibles entre eux, dans la limite évidemment de leurs intervalles. C'est-à-dire qu'on ne peut pas attribuer à une variable d'un certain type une valeur qui dépasse l'intervalle de valeurs de ce type. Nous avons vu les entiers. Nous avons vu qu'il existe quatre types d'entiers, que la différence principale qui existe entre eux c'est tout simplement l'intervalle de valeurs que chaque type définit. Nous avons vu rapidement le principe de codage en binaire, et nous avons vu aussi comment représenter et spécifier des valeurs en entiers, soit par défaut en type Int, soit en utilisant le symbole l en valeur Long. [MUSIQUE] [MUSIQUE]
