Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Please login or create an account
Change language to: English - Português - 日本語 - Русский
Aide de Scilab >> Fonctions Elémentaires > Virgule flottante > double

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

VersionDescription
6.0 Les nouveaux types d'entiers int64 and uint64 sont maintenant convertibles.
Scilab Enterprises
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors
Last updated:
Mon Feb 12 19:15:26 CET 2018