Formation I.S.N.

Codage des nombres réels

Les principes

Une problématique 




		
		
 
	

				







 
La représentation en virgule flottante 
 
 


En informatique, les nombres réels qui ne sont pas des entiers signés sont représentés par des approximations appelées flottants.  
  



Notation scientifique usuelle : \(a =  ± m\times10^e\)  


    	

  • Avec \(m\) un nombre décimal de l'intervalle \([1 ; 10[\) appelé mantisse.
    • 

  • \(e\) un entier relatif appelé exposant. 
    • 





 

 Exemple :     
\(123 400 000\) s’écrit \(1,234×10^8\) en notation scientifique. 




On peut aussi utiliser des puissances de 2 :  \(a = m’\times2^{e'}\)  
 
 Exemple de normalisation :  \[ ± 1,\fbox{ ... }\times2^{\,\fbox{ ... }} \]



    	

  • 1 bit de signe, 
    • 

  • 23 bits pour coder la valeur de la mantisse (puissances négatives de 2), 
    • 

  • 8 bits pour coder la valeur de l’exposant (puissances positives de 2). 
    • 









  
Le standard utilisé par les ordinateurs 
 
 
				


Standard IEEE 754 simple précision (4 octets)  


 
\[(-1)^s\times(1,f)\times2^{e-127}\] 

 avec f = partie fractionnaire de la mantisse 






	
      1 bits       
		8 bits   
		  23 bits  

	
   s = signe 
		   e  = exposant décalé
		    f = pseudo-mantisse   







  

    	

  • e est codé sous forme de puissances positives de 2, 
    • 

  • f est codé sous forme de puissances négatives de 2. 
    • 




			








		
		



		
		
		
 Exemples d'encodage



		

		    

			
    
				
  •  -2.625
    • 
                
  •  0.1
    • 
			

			
   
				
 
 				


 Représentation IEEE 754 simple précision de \(x = -2,625\) 



x est  négatif, donc s = 1.  

La valeur absolue peut s’exprimer comme somme de puissances positives et négatives de 2 :




\( \begin{align}
2,625 &= 2 + 0,5 + 0,125\\
&= 1\times2^1 + 0\times2^0 + 1\times2^{-1} + 0\times2^{-2} + 1\times2^{-3}\\ 
&= [10,101]_2\\
\end{align}\) 


Il faut normaliser pour que la mantisse s’écrive «\(1,\cdots\) » :

 Ici on décale la virgule d’un cran à gauche : \(1,0101.2^1\)

 
  
   
   
 Identification : \((1,f)\times2^{e-127} = 1,0101\times2^1\)



On a donc : 
 
 mantisse \(= 1,01010000000000000000000_{2}\)  

 \(e - 127 = 1\)   
 
 donc \( e = 128_{10} = 10000000_{2}\)

 

 






	
      1       
		 10000000     
		  01010000000000000000000 

	
   s = signe 
		   e  = exposant décalé
		    f = pseudo-mantisse   






  

  
   Puis \(x = [-2,625]_{10}\) est codé par : \( 11000000001010000000000000000000\) 

 


Un site  en ligne pour vérifier.
  
 



















 Représentation IEEE 754 simple précision de \(x = 0,1\) 

Problème : \(0,1\)  s’exprime avec un nombre fini de décimales en base \(10\) , mais pas en base \(2\)  !  

  

\([0,1]_{10} = [0,00011001100110011001100110011001100110011\dots]_2\)    

  

Avec un nombre fini de bits, l’ordinateur fait forcément une approximation !  

  

 Normalisation :     

 \([0,00011001100110011\dots]_2 = [1,1001100110011\dots]_2 \times2^{-4}\)   

 
 
   

\(f = [0,10011001100110011001101]_2 \)  (on arrondit au 23ème bit)  


\(e - 127 = -4\)    

donc \(e = [123]_{10} = [01111011]_2\)   

  

On obtient :   
 
  




	
      0       
		 01111011     
		  10011001100110011001101 

	
   s = signe 
		   e  = exposant décalé
		    f = pseudo-mantisse   






  

  
   Puis \(x = [0,1]_{10}\) est codé par : \( 00111101110011001100110011001101\) 

 


Un site  en ligne pour vérifier.  

 
 
 
 



Décodage  
 
 
 
 
 
\(x\)   est codé par\( 00111101110011001100110011001101 \)   
   
\(s = 0\)    
 
\(\begin{align}
e &= 2^0 + 2^1 + 2^3 + 2^4 + 2^5 + 2^6\\    
&= 1 + 2 + 8 + 16 + 32 + 64 \\   
&= 123\\
\end{align}\) 
 
 
 
 
\(\begin{align}
f &= 2^{-1} + 2^{-4} + 2^{-5} + 2{^-8} + 2^{-9} + 2^{-12} + 2^{-13} + 2^{-16} + 2^{-17} + 2^{-20}+ 2^{-21} + 2^{-23}  \\
&= 0,5 + 0,0625 + ... + 0,000000119209289550781\\
&=0,599999904632568\\
\end{align}\)  
 
 

 
 
On obtient   
 
\(\begin{align}
x& = (-1)^{0}\times(1 + 0,599999904632568)\times2^{123-127}\\ 
&=1\times1.599999904632568\times2^{-4}\\
&= 0,100000001490116\\
\end{align}\) 
 
 
 
 
L’ordinateur NE PEUT PAS manipuler exactement 0,1 sous forme de flottant !
 
 Ceci induit des comportements qui peuvent sembler étranges...