int8 conversion au codage entier à 1 octet
int16 conversion au codage entier à 2 octets
int32 conversion au codage entier à 4 octets
int64 conversion au codage entier à 8 octets
uint8 conversion au codage entier non signé à 1 octet
uint16 conversion au codage entier non signé à 2 octets
uint32 conversion au codage entier non signé à 4 octets
uint64 conversion au codage entier non signé à 8 octets

## Séquence d'appel

                y = int8(X)
                y = int16(X)
                y = int32(X)
                y = int64(X)
                y = uint8(X)
                y = uint16(X)
                y = uint32(X)
                y = uint64(X)

## Arguments

X

  matrice de booléens, d'entiers encodés, ou de nombres décimaux réels ou complexes.

y

  matrice d'entiers encodés sur 1, 2, 4 ou 8 octets. size(y) == size(X).

## Description

Convertit et stocke sous forme d'entiers. Ces types de données sont particulièrement intéressants pour stocker des images, de longs signaux, ...

Lorsque des éléments de `X` ont une partie décimale non nulle, celle-ci est toujours tronquée (arrondie vers 0).

Exemple: `int8([-3.6, -2.5, -1.4, 1.3, 3.5, 6.7]) // = [-3, -2, -1, 1, 3, 6]`.

Les valeurs de `X` hors de l'intervalle cible sont modulotées (non saturées). Exemples:

- `int8([127 128 129 130]) // = [127 -128 -127 -126]`.
- `uint8([254 255 256 257]) // = [254 255 0 1]`.

-%inf est toujours converti en la borne inférieure de l'intervalle des valeurs possibles (voir ci-dessous).

%inf est toujours converti en la borne supérieure de l'intervalle des valeurs possibles.

%nan est toujours converti en 0.

Si `X` est encodé en nombres complexes, les parties imaginaires de ses éléments sont ignorées. Seules les parties réelles converties sont retournées.

[%f %t] est toujours converti en [0 1].

Convertir en nombres décimaux de grands entiers encodés en int64 or uint64 peut changer leur valeur et diminuer leur précision relative. En effet, la valeur des entiers int64 | uint64 est encodée sur 63|64 bits, alors que la mantisse des nombres décimaux est encodée sur 53 bits seulement. Pour plus de détails, voir la page de la fonction double() et un exemple ci-dessous.

La conversion de `[]` ne change rien : son type 1 est toujours conservé (type numérique décimal).

Fonction | y dans | =
--- | --- | ---
int8(X) | [- 27, 27-1] | [-128, 127]
int16(X) | [- 215, 215-1] | [-32768, 32767]
int32(X) | [- 231, 231-1] | [-2147483648, 2147483647]
int64(X) | [- 263, 263-1] | [-9223372036854775808, 9223372036854775807]
uint8(X) | [0, 28-1] | [0, 255]
uint16(X) | [0, 216-1] | [0, 65535]
uint32(X) | [0, 232-1] | [0, 4294967295]
uint64(X) | [0, 264-1] | [0, 18446744073709551615]

## Exemples

Arrondis vers 0 et congruences ; valeurs spéciales :

    int8([-11.7 -8.5 -6.4  6.4 8.5 11.7])
    int8([-130 -129 -128 -127 126 127 128 129])
    a = -129 + 256*(-3:3)
    int8(a)
    int8([-%inf %inf %nan])

    --> int8([-11.7 -8.5 -6.4  6.4 8.5 11.7])
     ans  =
     -11 -8 -6  6  8  11

    --> int8([-130 -129 -128 -127 126 127 128 129])
     ans  =
      126  127 -128 -127  126  127 -128 -127

    --> a = -129 + 256*(-3:3)
     a  =
      -897.  -641.  -385.  -129.   127.   383.   639.

    --> int8(a)
     ans  =
      127  127  127  127  127  127  127

    --> int8([-%inf %inf %nan])
     ans  =
     -128  127  0

À propos des effets de congruence (modulo) et des limites supérieures des encodages entiers non signés :

    uint8([-1 %inf])
    uint16([-1 %inf])
    uint32([-1 %inf])
    uint64([-1 %inf])

    --> uint8([-1 %inf])
     ans  =
      255  255

    --> uint16([-1 %inf])
     ans  =
      65535  65535

    --> uint32([-1 %inf])
     ans  =
      4294967295  4294967295

    --> uint64([-1 %inf])
     ans  =
      18446744073709551615  18446744073709551615

Convertir de grands entiers encodés sur 64 bits en nombres décimaux altère leur valeur et dégrade leur précision relative :

    i = uint64(2)^63 - 600
    i - uint64(double(i))

    --> i = uint64(2)^63 - 600
     i  =
      9223372036854775208

    --> i - uint64(double(i))
     ans  =
      424

Conversion de booléens et de nombres complexes :

    int8([%f %t])

    int8(-10.2 + 3.4*%i)
    uint8(-10.2 + 3.4*%i)

    --> int8([%f %t])
     ans  =
      0  1

    --> int8(-10.2 + 3.4*%i)
     ans  =
     -10

    --> uint8(-10.2 + 3.4*%i)
     ans  =
      246

[] n'est pas convertible:

    i = uint16(3);
    i(1,2) = 5.6
    typeof(i)

    i = uint16([])
    i(1,2) = 2.3
    typeof(i)

    --> i = uint16(3);
    --> i(1,2) = 5.6
     i  =
      3  5

    --> typeof(i)
     ans  =
     uint16

    --> i = uint16([])
     i  =
        []

    --> i(1,2) = 2.3
     i  =
       0.   2.3

    --> typeof(i)
     ans  =
     constant

## Voir aussi

- iconvert
- inttype
- double
- dec2bin
- dec2base

## Historique

6.0

- int64() et uint64() ajoutées à Scilab.
- Les nombres complexes sont désormais acceptés.

- Ceci | vaut désormais | au lieu de
  --- | --- | ---
  int8([-%inf, %inf]) | [-128, 127] | [0, 0]
  int16([-%inf, %inf]) | [-32768, 32767] | [0, 0]
  int32(%inf) | 2147483647 | -2147483648
  uint8(%inf) | 255 | 0
  uint16(%inf) | 65535 | 0
  uint32(%inf) | 4294967295 | 0