int8 conversion en entier sur 1 octet
int16 conversion en entier sur 2 octets
int32 conversion en entier sur 4 octets
int64 conversion en entier sur 8 octets
uint8 conversion en entier non signé sur 1 octet
uint16 conversion en entier non signé sur 2 octets
uint32 conversion en entier non signé sur 4 octets
uint64 conversion en entier non signé sur 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. Matrice de strings représentant des grands nombres litéraux, pour `int64` et `uint64`.

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].

Lecture de grands entiers litéraux avec `int64()` ou `uint64()` : Tout appel tel que `int64(1000000000000000000)` considère implicitement `1000000000000000000` comme un entier décimal dont la mantisse est encodée sur seulement 53 bits < 64 bits. Ainsi, cette mantisse sera ici tronquée, et l'entier obtenu après cette troncature ne sera en général pas celui fourni. Afin d'éviter cet effet, les grands entiers peuvent être fournis en chaine de caractères : `int64("1000000000000000000")` donnera l'entier attendu, sans perte de précision. Pour plus de détails concernant la précision pour les grands entiers, 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

Lecture d'entiers int64 or uint64 supérieurs à 2^53, sans effet de troncature :

    a = [uint64(1000000000000001000) ; uint64("1000000000000001000")]
    typeof(a)

    a = [int64(-1000000000000001000) ; int64("-1000000000000001000")]
    typeof(a)

    --> a = [uint64(1000000000000001000) ; uint64("1000000000000001000")]
     a  =
      1000000000000001024
      1000000000000001000

    --> typeof(a)
     ans  =
      "uint64"

    --> a = [int64(-1000000000000001000) ; int64("-1000000000000001000")]
     a  =
     -1000000000000001024
     -1000000000000001000

    --> typeof(a)
     ans  =
      "int64"

[] 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

6.1.2 `int64` et `uint64` acceptent des strings représentant des entiers litéraux pouvant être > 253, et les interprètent sans effet de troncature.