Scilab Website | Contribute with GitLab | Mailing list archives | ATOMS toolboxes

Scilab Online Help
2025.0.0 - Français

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)	[- 2⁷, 2⁷-1]	[-128, 127]
int16(X)	[- 2¹⁵, 2¹⁵-1]	[-32768, 32767]
int32(X)	[- 2³¹, 2³¹-1]	[-2147483648, 2147483647]
int64(X)	[- 2⁶³, 2⁶³-1]	[-9223372036854775808, 9223372036854775807]
uint8(X)	[0, 2⁸-1]	[0, 255]
uint16(X)	[0, 2¹⁶-1]	[0, 65535]
uint32(X)	[0, 2³²-1]	[0, 4294967295]
uint64(X)	[0, 2⁶⁴-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 — conversion en entiers encodés sur 1, 2, 4 ou 8 octets
inttype — type des entiers utilisés dans les types entiers de données.
double — convertit des entiers inttype ou des booléens en encodage décimal
dec2bin — convert from decimal to binary
dec2base — Convert decimal to base N number in string

Historique

Version Description

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 > 2⁵³, et les interprètent sans effet de troncature.

Report an issue
<< iconvert	Entiers	inttype >>

Copyright (c) 2022-2024 (Dassault Systèmes)
Copyright (c) 2017-2022 (ESI Group)
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors

Last updated:
Thu Oct 24 11:15:58 CEST 2024