Scilab 6.0.1
Please note that the recommended version of Scilab is 2025.0.0. This page might be outdated.
See the recommended documentation of this function
double
convertit des entiers inttype ou des booléens en encodage décimal
Syntaxe
y = double(X)
Paramètres
- X
matrice d'entiers encodés ou de booléens
- y
matrice de nombres en notation décimale
Description
Convertit des nombres entiers encodés sur 1, 2, 4 ou 8 octets
en nombres décimaux encodés sur 8 octets.
Si X est déjà encodée en notation décimale,
double() ne fait rien.
 | double() et iconvert(..,0)
sont équivalentes et ont la même vitesse. |
| double() peut aussi convertir des booléens.
Cependant, la fonction dédiée bool2s() est environ
2 fois plus rapide. |
 | La mantisse des nombres entiers uint64 est
encodée sur 64 bits, alors que la mantisse des nombres en notation
décimale (double precision) est encodée sur 52 bits
seulement. La précision relative des entiers uint64
supérieurs à 252 peut donc être jusqu'à 212
~4000 fois meilleure
que celle de leur équivalent décimal "double".
En conséquence, l'utilisation de
double() sur des entiers int64 ou
uint64 supérieurs à 252 peut tronquer
leurs valeurs
par arrondi, et ainsi diminuer leur précision relative. Quelques
exemples donnés ci-dessous illustrent cet effet. |
Exemples
x = int8([0 12 140]) double(x) // double() arrondit et tronque les nombres int64() or uint64() supérieurs à 2^52 // ------------------------------------------------------------------------------ i = int64(2)^52 // 52 bits, comme pour la mantisse des décimaux i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] err = i - double(i) // pas de différence, pour les |entiers|<= 2^52 i = int64(2)^53 // valeur sur 53 bits => mantisse + précise que celle des décimaux i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] err = i - double(i) // Des erreurs d'arrondi dues à double() apparaissent i = int64(2)^55 i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] err = i - double(i) i = int64(2)^62 // L'amplitude des erreurs est ~ 2^(n-52) i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] err = i - double(i)
--> i = int64(2)^52 // 52 bits, comme pour la mantisse des décimaux i = 4503599627370496 --> i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] i = 4503599627370496 4503599627370499 4503599627370526 4503599627370499 4503599627370529 4503599627370826 4503599627370502 4503599627370559 4503599627371126 4503599627370505 4503599627370589 4503599627371426 --> err = i - double(i) // pas de différence, pour les |entiers|<= 2^52 err = 0 0 0 0 0 0 0 0 0 0 0 0 --> i = int64(2)^53 // valeur sur 53 bits => mantisse + précise que celle des décimaux i = 9007199254740992 --> i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] i = 9007199254740992 9007199254740995 9007199254741022 9007199254740995 9007199254741025 9007199254741322 9007199254740998 9007199254741055 9007199254741622 9007199254741001 9007199254741085 9007199254741922 --> err = i - double(i) // Des erreurs d'arrondi dues à double() apparaissent err = 0 -1 0 -1 1 0 0 -1 0 1 1 0 --> i = int64(2)^55 i = 36028797018963968 --> i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] i = 36028797018963968 36028797018963971 36028797018963998 36028797018963971 36028797018964001 36028797018964298 36028797018963974 36028797018964031 36028797018964598 36028797018963977 36028797018964061 36028797018964898 --> err = i - double(i) err = 0 3 -2 3 1 2 -2 -1 -2 1 -3 2 --> i = int64(2)^62 // L'amplitude des erreurs est ~ 2^(n-52) i = 4611686018427387904 --> i = [i+(0:3:9)' i+(3:30:93)' i+(30:300:930)'] i = 4611686018427387904 4611686018427387907 4611686018427387934 4611686018427387907 4611686018427387937 4611686018427388234 4611686018427387910 4611686018427387967 4611686018427388534 4611686018427387913 4611686018427387997 4611686018427388834 --> err = i - double(i) err = 0 3 30 3 33 330 6 63 -394 9 93 -94
// Vitesses comparées de double(), bool2s() et iconvert(,0) sur des booléens // ------------------------------------------------------------------------- b = (rand(1000,1000)<0.5); tic(),for i=1:100, bool2s(b); end, toc() tic(),for i=1:100, double(b); end, toc() tic(),for i=1:100, iconvert(b,0); end, toc()
--> b = (rand(1000,1000)<0.5); --> tic(),for i=1:100, bool2s(b); end, toc() ans = 1.1680533 --> tic(),for i=1:100, double(b); end, toc() ans = 2.9003021 --> tic(),for i=1:100, iconvert(b,0); end, toc() ans = 2.1867567
// Vitesses comparées de double() et iconvert(..,0) sur des entiers int32 // ---------------------------------------------------------------------- i = int32((rand(1000,1000)-0.5)*1000); tic(),for j=1:100, double(i); end, toc() tic(),for j=1:100, iconvert(i,0); end, toc()
--> i = int32((rand(1000,1000)-0.5)*10000); --> tic(),for j=1:100, double(i); end, toc() ans = 2.2464656 --> tic(),for j=1:100, iconvert(i,0); end, toc() ans = 2.2771408
Voir aussi
- iconvert — conversion au codage entier à 1, 2, 4 ou 8 octets
- bool2s — convertit une matrice booléenne en une matrice 0-1
- int8 — conversion au codage entier à 1 octet
- inttype — type des entiers utilisés dans les types entiers de données.
- type — Retourne le type d'un objet Scilab
- bin2dec — convert from binary to decimal
- oct2dec — convert from octal to decimal
- hex2dec — convert from hexadecimal to decimal
- base2dec — convert from base b to decimal
Historique
| Version | Description |
| 6.0 | Les nouveaux types d'entiers int64 and uint64 sont maintenant convertibles. |
| Report an issue | ||
| << clean | Virgule flottante | fix >> |