Valeurs limite des variables float et double

**Skagaz** · 16/02/2010, 12h17

Bonjour à tous,

Je poste ici pour comprendre les limites de ces 2 variables.
J'ai bien compris celles des variables d'entiers plus ou moins longs.
Exemple pour le byte qui vaut 8 bits, donc 256 valeurs possibles, comme on bosse en signé on en met 128 dans les negatifs et 128 dans les positifs.
Ainsi si je mets le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
byte b = 128; // valeur acceptée.
byte c = 130; // valeur refusée, on me cast.

Il en est de même pour tous les autres types d entiers char,int, long...

Pour ce qui est des floats et des doubles, je galère un peu plus.
Ils répondent à la norme IEEE 754:
- le float est de simple précision (32 bits : 1 bit de signe, 8 bits d'exposant (-126 à 127), 23 bits de mantisse),
- le double est de double précision (64 bits : 1 bit de signe, 11 bits d'exposant (-1022 à 1023), 52 bits de mantisse),

Alors pourquoi quand je rentre le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
float f = 130.0f;

Je ne me fais pas caster ? la valeur de la partie entière du nombre excède celle qui devrait être autorisée ? Est-ce que java utilise des bits non nécessaires de la mantisse pour allouer une plus grande valeur à ma partie entière que celle qui devrait être autorisée ?

**adiGuba** · 16/02/2010, 12h28

Salut,

Le stockage des nombres flottants est bien plus complexe, et peut représenter une plage bien plus importante de nombre. Dans ton exemple tu oublies la mantisse.

Grosso modo pour obtenir le nombre il faut faire ce calcul : mantisse * 2 ^ exposant

Tu as donc une plage de valeur représentable bien plus grande...
(voir Float.MAXT_VALUE et Double.MAX_VALUE)

a++

**rtg57** · 18/02/2010, 18h02

Bonjour, il y a un petit truc sympa sur Wikipédia: http://fr.wikipedia.org/wiki/Virgule_flottante

Attention, même si ces nombres peuvent encaisser des valeurs monstrueuses, on est parfois déçu par le perte de précision lorsqu'on additionne des montants au centime d'euro.

Pour revenir plus sur le sujet, avec une mantisse sur 23 bits, on peut déjà atteindre un nombre bien plus conséquent que sur 8 bits. Donc "130" passe largement (sans parler de l'élévation à la puissance de l'exposant )

En espérant que cela réponde à votre question...

**danimo** · 19/02/2010, 13h12

Salut,

Tout d'abord, voici comment connaître les valeurs mini et maxi d'un type byte:

VALEUR MINI d'un BYTE.
>>>> byte mon_byte = Byte.MIN_VALUE;
La valeur minimale d'un byte est -128

VALEUR MAXI d'un BYTE.
>>>> byte mon_byte = Byte.MAX_VALUE;
La valeur maximale d'un byte est 127

Donc les 2 valeurs dont tu parles:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
byte b = 128;
byte c = 130;

dépassent toutes le 2 la valeur maxi d'un byte.
javac signal les 2 erreurs suivantes:
------------.java:nnn: possible loss of precision
found : int
required: byte
byte b = 128; possible loss of precision
^
et
------------.java:nnn: possible loss of precision possible loss of precision
found : int
required: byte
byte c = 130; possible loss of precision
^

Ce que l'on peut interpréter come ceci:

j'ai trouvé une valeur (128 ou 130) qui dépasse la valeur maxi du type byte.

On ne peut donc pas éxécuter le programme.

par contre si on a:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
byte b = 127;
         b++;
System.out.println("b = " + b);

le compilateur accepte (la syntaxe est correcte)

On exécute donc et on affiche b = -128

Il n'y a pas d'exception levée mais alors qu'on pouvait s'attendre à obtenir:
b = 128 (ce qui n'est pas possible) on obtient la -128.
avec b+=2 >>>> -127 et en fait c'est imprévisible.
En principe on ne fait pas de calculs sur un byte. Mais si on en fait il vaut mieux utiliser b = b + 1 qui provoquera une erreur de compilation, plutot que b++, ou b = b + 100, aulieu de b+= 100.

Par contre avec les autres types d'entiers,par exemple int:
i = 3456789012; javac signale:
integer number too large: 3456789012

FLOAT:

Ce ne sont ni la partie entière ni la partie décimale qui sont limitées, mais bien toute la valeur du float.

VALEUR MINI d'un FLOAT.
>>>> float mon_float = Float.MIN_VALUE;
La valeur minimale d'un float est 1.4E-45
soit 1.4 * 10 puissance -45

VALEUR MAXI d'un FLOAT.
>>>> float mon_float = Float.MAX_VALUE;
La valeur maximale d'un float est 3.4028235E38
soit 3.4028235 * 10 puissance 38

Attention:

float f = 3.4028235E38; // err. compile: trouvé double aulieu de float et
//possible lost..... car il manque le f (ou F).

float f = 3.4028235E38f; // ok

float f = 3.4028236E38f; // err floating point number too large

Cordialement,

Dan

**danimo** · 19/02/2010, 13h38

RE,

Format général pour VALEUR MINI et VALEUR MAXI pour les entiers et réels :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
le_type mon_type = Type.MIN_VALUE; // exemple: = Double.MIN_VALUE;
le_type mon_type = Type.MAX_VALUE; // ex. = Long.MAX_VALUE;
 
//  SAUF pour int:
 
le_type mon_type = Integer.MIN_VALUE; // et non Int
le_type mon_type = Integer.MAX_VALUE; // et non Int

dan

**Pill_S** · 22/02/2010, 19h34

Envoyé par danimo

Il n'y a pas d'exception levée mais alors qu'on pouvait s'attendre à obtenir:
b = 128 (ce qui n'est pas possible) on obtient la -128.
avec b+=2 >>>> -127 et en fait c'est imprévisible.

c'est tout sauf imprévisible. il suffit d'écrire le résultat attendu en binaire, et de supprimer tout ce qui "dépasse" du byte (c'est d'ailleurs ce que fait la jvm: elle tronque le résultat)

En principe on ne fait pas de calculs sur un byte.

bien sûr qu'on en fait... quand on est sur de son coup...

d'ailleur, petit détail, mais la jvm ne sait pas faire de calcul directement sur des byte ou des short. Il y a promotion vers un int lors de chaque calcul, puis re-conversion du résultat lorsque c'est nécessaire.

ex: byte b=0; b += 2;

lorsque l'on fait b+=2, b est promu vers un int, ensuite on ajoute 2 à cet int, puis on re-convertit le résultat vers un byte que l'on stocke dans b.

voili pour la ptite histoire

**sanchou** · 15/04/2010, 10h45

Bonjour,

désolé de remonter ce sujet, mais malgré toutes vos explications (qui correspondent à peu près à ce que je savais déjà), j'ai une interrogation sur les nombres négatifs.
En effet, si Float.MIN_VALUE=1.4E-45 et Float.MAX_VALUE=3.4028235E38, un nombre négatif ne devrait pas être accepté non?
De même qu'en est-il du zéro?
Peut-on considérer que l'ensemble des float se situe dans l'ensemble ;
[-Float.MAX_VALUE;-Float.MIN_VALUE] U [Float.MIN_VALUE;Float.MAX_VALUE]?

Merci d'avance de votre réponse.

Nico

**thelvin** · 15/04/2010, 11h15

Je dirais plutôt [-Float.MAX_VALUE;-Float.MIN_VALUE] U [Float.MIN_VALUE;Float.MAX_VALUE] U {0f ; -0f ; Float.POSITIVE_INFINITY ; Float.NEGATIVE_INFINITY}

Et éventuellement NaN.

Mais c'est ça, oui.

**sanchou** · 15/04/2010, 11h29

Envoyé par thelvin

Je dirais plutôt [-Float.MAX_VALUE;-Float.MIN_VALUE] U [Float.MIN_VALUE;Float.MAX_VALUE] U {0f ; -0f ; Float.POSITIVE_INFINITY ; Float.NEGATIVE_INFINITY}

Et éventuellement NaN.

Mais c'est ça, oui.

Merci de ta réponse.
Cà parait logique mais je n'ai trouvé nulle part une représentation sous forme d'ensemble des float et double.

Nico

**danimo** · 15/04/2010, 11h18

Salut,

Reprenons les valeurs mini et maxi d'un Float:

MIN_VALUE=1.4E-45
MAX_VALUE=3.4028235E38

celà signifie bien que toutes les valeurs possibles sont les valeurs de:
1.4E-45 à 3.4028235E38.
Le zéro est bien une de ces valeurs.

Un nombre négatif, pourvu qu'il soit >= 1.4E-45 sera bien < 3.4028235E38
Un nombre positif, pourvu qu'il soit <= 3.4028235E38 sera bien > 1.4E-45

Cordialement,

Dan