Nombres entiers

Classes de nombres entiers

MATLAB^® propose quatre classes de nombres entiers signés et quatre classes de nombres entiers non signés. Les types signés vous permettent de travailler avec des nombres entiers négatifs et positifs. Toutefois, ils ne peuvent pas représenter une plage de nombres aussi étendue que les types non signés, car un bit sert à désigner le signe positif ou négatif du nombre. Les types non signés peuvent contenir une plage de nombres plus étendue, mais ces nombres peuvent uniquement être positifs ou nuls.

MATLAB supporte le stockage des données entières sur 1, 2, 4 et 8 octets. En utilisant le plus petit type entier pouvant contenir vos données, vous pouvez économiser de la mémoire et réduire le temps d’exécution de vos programmes. Par exemple, vous n’avez pas besoin d’un nombre entier de 32 bits pour stocker la valeur 100.

Le tableau suivant répertorie les huit classes de nombres entiers, la plage de valeurs que vous pouvez stocker dans chaque type et la fonction de conversion MATLAB requise pour le créer.

Classe	Plage de valeurs	Fonction de conversion
Nombre entier 8 bits signé	–2⁷ à 2⁷–1	`int8`
Nombre entier 16 bits signé	–2¹⁵ à 2¹⁵–1	`int16`
Nombre entier 32 bits signé	–2³¹ à 2³¹–1	`int32`
Nombre entier 64 bits signé	–2⁶³ à 2⁶³–1	`int64`
Nombre entier 8 bits non signé	0 à 2⁸–1	`uint8`
Nombre entier 16 bits non signé	0 à 2¹⁶–1	`uint16`
Nombre entier 32 bits non signé	0 à 2³²–1	`uint32`
Nombre entier 64 bits non signé	0 à 2⁶⁴–1	`uint64`

Créer des données entières

Par défaut, MATLAB stocke les données numériques sous forme de valeurs à virgule flottante double précision (double). Pour stocker les données sous forme de nombres entiers, vous devez convertir le type double vers le type entier souhaité. Utilisez l’une des fonctions de conversion indiquées dans le tableau ci-dessus.

Par exemple, pour stocker 325 sous forme de nombre entier 16 bits signé affecté à la variable x, saisissez :

x = int16(325);

Si le nombre converti en nombre entier a une partie fractionnaire, MATLAB l’arrondit au nombre entier le plus proche. Si la partie fractionnaire est exactement égale à 0.5, MATLAB choisit le nombre entier le plus proche dont la valeur absolue a une amplitude supérieure :

x = 325.499;
int16(x)

ans =
	
  int16

   325

x = x + .001;
int16(x)

ans =

  int16

   326

Si vous souhaitez arrondir un nombre en utilisant un schéma d’arrondi autre que celui par défaut, MATLAB propose quatre fonctions d’arrondi : round, fix, floor et ceil. La fonction fix permet de remplacer le schéma par défaut et d’arrondir vers zéro en cas de partie fractionnaire non nulle :

x = 325.9;
int16(fix(x))

ans =

  int16

   325

Les opérations arithmétiques impliquant à la fois des nombres entiers et à virgule flottante donnent toujours un résultat de type entier. Si nécessaire, MATLAB arrondit le résultat avec l’algorithme d’arrondi par défaut. L’exemple ci-dessous donne une réponse exacte égale à 1426.75 que MATLAB arrondit ensuite à l’arrondi supérieur le plus proche :

int16(325)*4.39

ans =

  int16

   1427

Les fonctions de conversion de nombres entiers sont également utiles pour convertir en nombres entiers d’autres classes telles que des vecteurs de caractères :

chr = 'Hello World';
int8(chr)

ans =

  1×11 int8 row vector

    72   101   108   108   111    32    87   111   114   108   100

Si vous convertissez une valeur NaN vers une classe de nombres entiers, le résultat est la valeur 0 dans cette classe. Par exemple :

int32(NaN)

ans =

  int32

   0

Opérations arithmétiques sur des classes de nombres entiers

MATLAB peut effectuer des opérations arithmétiques entières sur les types de données suivants :

Nombres entiers ou tableaux de nombres entiers du même type. Les opérations donnent un résultat de même type que les opérandes :
```
x = uint32([132 347 528]) .* uint32(75);
class(x)
```
```
ans =
   'uint32'
```
Nombres entiers ou tableaux de nombres entiers et nombres scalaires à virgule flottante double précision. Les opérations donnent un résultat de même type que les opérandes entiers :
```
x = uint32([132 347 528]) .* 75.49;
class(x)
```
```
ans =
   'uint32'
```

Pour toutes les opérations binaires où l’un des opérandes est un tableau de type entier (à l’exception des nombres entiers 64 bits) et l’autre est un scalaire de type double, MATLAB effectue un calcul arithmétique double précision élément par élément, puis reconvertit le résultat vers le type entier d’origine. Pour les opérations binaires impliquant un tableau de nombres entiers 64 bits et un scalaire de type double, MATLAB effectue le calcul comme s’il s’agissait d’une arithmétique 80 bits à précision étendue pour éviter toute perte de précision.

Les opérations sur des nombres complexes de types entiers ne sont pas supportées.

Valeurs maximales et minimales des classes de nombres entiers

Pour chaque type de données entier, il existe un nombre maximal et un nombre minimal pouvant être représentés par ce type. Le tableau proposé dans Classes de nombres entiers répertorie les valeurs maximales et minimales de chaque type de données entier dans la colonne « Plage de valeurs ».

Vous pouvez également obtenir ces valeurs avec les fonctions intmax et intmin :

intmax("int8")

ans =

  int8

   127

intmin("int8")

ans =

  int8

   -128

Si vous convertissez un nombre qui est supérieur à la valeur maximale d’un type entier vers ce type, MATLAB le définit à la valeur maximale. De même, si vous convertissez un nombre qui est inférieur à la valeur minimale du type entier concerné, MATLAB le définit à la valeur minimale. Par exemple :

x = int8(300)

x =

  int8

   127

x = int8(-300)

x =

  int8

   -128

De plus, lorsque le résultat d’une opération arithmétique impliquant des nombres entiers dépasse la valeur maximale (ou minimale) du type de données, MATLAB le définit à la valeur maximale (ou minimale) :

x = int8(100)*3

x =

  int8

   127

x = int8(-100)*3

x =

  int8

   -128

Perte de précision due à la conversion

Lorsque vous créez un tableau numérique contenant de grands nombres entiers (supérieurs à flintmax), MATLAB représente initialement l’entrée en double précision par défaut. La conversion de cette entrée vers le type de données int64 ou uint64 peut entraîner une perte de précision. Pour préserver la précision, appelez int64 ou uint64 avec chaque élément scalaire du tableau à la place.

Par exemple, convertissez un tableau numérique de grands nombres entiers en tableau de nombres entiers 64 bits signés avec int64. Le tableau en sortie perd en précision.

Y_inaccurate = int64([-72057594035891654 81997179153022975])

Y_inaccurate = 1×2 int64 row vector

   -72057594035891656    81997179153022976

Au lieu de cela, appelez int64 avec chaque élément scalaire pour renvoyer un tableau précis.

Y_accurate = [int64(-72057594035891654) int64(81997179153022975)]

Y_accurate = 1×2 int64 row vector

   -72057594035891654    81997179153022975

Vous pouvez également créer le tableau de nombres entiers sans perdre en précision en utilisant les valeurs hexadécimales ou binaires des nombres.

Y_accurate = [0xFF000000001F123As64 0x1234FFFFFFFFFFFs64]

Y_accurate = 1×2 int64 row vector

   -72057594035891654    81997179153022975