Nombre flottant

[G-Rom]

Comment est représenté un nombre flottant en hexadécimal ?

[SPH]

Je ne sais pas si ta question a un sens. Reflechis bien

[G-Rom]

je pense que oui.

le nombre 4987 est représente ainsi en hexa :

00 00 00 00 00 00 13 7B

mais si je veut 4987.5 ?

le .5 je le représente comment ? dans une autre chaine hexa ?

$0000000000000005

admettons que oui , comment à partir de ces 2 chaines je recompose mon flottant ?

A.s = "$000000000000137B"
B.s = "$0000000000000005"

C.f = ?

[flaith]

Je ne sais pas si ta question a un sens. Reflechis bien

Si si elle a un sens car la représentation de nombre en virgule flottante est différente car il y a l'exposant, la mantisse et le signe qu'il faut convertir en hexa

[G-Rom]

tu as un exemple à porté de main flaith ?

[djes]

L'hexa n'a rien à voir là-dedans. Tu as un très bon article sur wikipedia (surtout en anglais) : http://fr.wikipedia.org/wiki/Virgule_flottante
En gros selon la norme choisie, tu as un certain nombre de bits pour représenter l'exposant, d'autres pour la mantisse, et un bit pour le signe, ce qui donne signe.mantisse.2^exposant
En hexa, ça ne veut souvent pas dire grand chose, difficile de s'y repérer, d'autant que les bits ne sont pas alignés sur des quartets. (voir là : http://babbage.cs.qc.edu/IEEE-754/Decimal.html)

[G-Rom]

en fait mon problème est que j'ai une suite d'instruction basique , chaque instruction est codé sur un octet
par exemple , l'instruction 0x01 pousse une valeur immédiate dans une pile :

ici , je pousse la valeur 4987 dans une pile :

0x01
0x00
0x00
0x00
0x00
0x00
0x00
0x13
0x7B

Pour un flottant , je dois calculer chaque octet pour obtenir le nombre flottant adéquat de cette manière si j'ai bien compris :
[1][00000000][00000000000000000000000]
Signe , exposant , mantisse , et à partir de ce nombre binaire , le convertir en hexa.
c'est bien ca ?

[djes]

Oui, ça m'a l'air d'être ça si tu bosses en IEEE-754.

[G-Rom]

en ayant suivi ce lien que tu m'a donné http://babbage.cs.qc.edu/IEEE-754/Decimal.html
j'ai testé avec le nombre 23.5
qui me sort le binaire , et l'hexa : 41BC0000

Ma nouvelle question est donc , comment transformé mon hexa en .f sous pb ? ou le binaire...

[flaith]

Sympa les liens, merci

en recherchant de la doc je suis tombé sur ce lien : http://hal.inria.fr/inria-00071477

en commençant à le lire j'ai vu ca :

L'importance du traitement des exceptions est parfaitement illustrée par le crash du vol
501 d'Ariane en 1996, qui a coûté quelques 500 millions de dollars. L'origine du problème
s'est avérée être une erreur de programmation dans le système de référence inertielle. Plus
précisément, un flottant 64 bits donnant la vitesse horizontale de la fusée était converti en
entier signé sur 16 bits. Or l'entier obtenu étant plus grand que 32767, le plus grand entier
représentable sur 16 bits, la conversion échouait, déclenchant une exception non traitée. Le
plus drôle " si l'on peut dire " dans cette histoire est que tous les tests logiciels avaient
été réussis, mais ils avaient été effectués avec les données d'Ariane 4, fusée moins puissante
et donc moins rapide qu'Ariane 5, pour laquelle la vitesse horizontale restait inférieure au
maximum de 32767 !

[djes]

en ayant suivi ce lien que tu m'a donné http://babbage.cs.qc.edu/IEEE-754/Decimal.html
j'ai testé avec le nombre 23.5
qui me sort le binaire , et l'hexa : 41BC0000

Ma nouvelle question est donc , comment transformé mon hexa en .f sous pb ? ou le binaire...

Oulà, tu me demandes ça à cette heure-ci?
Il est fou!
Pourquoi tu reparles d'hexa, je sais pas mais bon. Ben ton hexa, si pb n'est pas capable de le traiter tel quel, tu le copies bit à bit en pokant dans l'adresse mémoire de ton float, et normalement PB devrait n'y voir que du feu.

flaith>

[SPH]

Moi, la question qui me parait peut etre le plus adapté est : ou se trouve la partie non entiere d'un flottant ?
Car je n'ai jamais vu un hexa non entier... Si ca existe, je viens d'apprendre un truc

[djes]

C'est relatif, nos ordinateurs ne connaissent que le binaire, donc oui, ils ne connaissent que les entiers, mais ils sont faits de telle sorte qu'ils puissent traiter des nombres flottants, de même qu'un DSP est fait pour traiter des données analogiques.
Le binaire à virgule, je ne connais pas, mais ça doit être possible, de même que l'hexa, comme le décimal

[PAPIPP]

Bonjour à tous

Code : Tout sélectionner

Je m’intéresse depuis longtemps à la représentation des nombres en machine j’ai réalisé un ensemble de procédures  (ci-dessous) permettant de contrôler les aspects techniques 
 J’ai fait appel à mes souvenirs mais surtout à internet
Tout d’abord il est important de savoir que dans les langues latines nous écrivons de la gauche vers la droite et que nous représentons les nombres en Big indian les poids des chiffres les plus forts en premier exemple cent trente quatre s'écrit 134  mais en machine  les nombre sont écrits en little-endian chez Intel ; Ainsi les poids des chiffres les plus forts sont écrits  en dernier. Exemple $03FE s'écrit en mémoire de l’adresse la plus faible à l’adresse la plus forte FE03  l’entité de base en norme IA32 est l’octet L’inversion sera donc réalisée octet par octet et tout ce qui va être dit ici est relatif à cette norme mais aussi à la norme IEEE-754 
(.Pour la norme IA64 adoptée sur les machines 64bits c’est le mot (2 octets) qui peut être pris comme base d’inversion
Donc $03FE en Big indian  ou en little indian norme IA32 donne  FE03=(256^0)*FE+(256^1)*3=1022 
La norme IEEE 754 (reprise par la norme internationale CEI 60559) spécifie deux formats de nombres en virgule flottante (et deux formats étendus optionnels) et les opérations associées. La quasi-totalité des Architectures d'ordinateurs actuelles, y compris IA32, PowerPC, et AMD64, incluent une implémentation matérielle des calculs sur flottants IEEE, directement dans le microprocesseur, garantissant une exécution rapide.
Les deux formats fixés par la norme IEEE 754 sont sur 32 bits (« simple précision ») et 64 bits (« double précision »). La répartition des bits est la suivante, où 1 ≤ M < 2 : pour les nombres normalisés
                     Encodage      Signe Exposant Val centre Expo   Mantisse   Valeur d'un nombre
Simple précision   32 bits         1 bit  8 bits     2^(8-1)-1=127	23 bits    (-1)^S*m*2^(e-127)
Double précision   64 bits         1 bit 11 bits    2^(11-1)-1=1023	52 bits   (-1)^S*m*2^(e-1023) 

Le tableau ci-dessus indique les bits représentés. Le premier bit de la mantisse d'un nombre normalisé étant toujours 1, il n'est pas représenté dans ces deux formats : on parle de bit implicite. Pour ces deux formats, les précisions sont donc respectivement de 24 et de 53 bits.
Flottants étendus
Certaines implémentations ajoutent un ou plusieurs types de précision supérieure (ainsi, IA32 a un type étendu sur 80 bits). La norme IEEE 754 prévoit des tailles minimales pour ces types étendus :

                               Signe      Exposant            Mantisse
Simple précision étendue       1 bit    11 bits ou plus   32 bits ou plus
Double précision étendue       1 bit    15 bits ou plus   64 bits ou plus

Ces représentations « étendues » n'utilisent pas forcément le bit implicite de la mantisse.
Dans la pratique, seule la double précision étendue est encore utilisée, dans sa forme minimale (1+15+64 = 80 bits, le fameux type étendu de l'IA32).
Lorsque les flottants IEEE offrent une précision insuffisante, on peut devoir recourir à des calculs sur des flottants en précision supérieure. Citons notamment la bibliothèque MPFR.
Tous les calculs en FPU (Floating Point Unit) (Unité de calcul flottant) chez Intel .sont réalisés sur 80 bits double précision étendue 
Par exemple, dans le langage C, le compilateur gcc pour les architectures compatible Intel 32 bits utilise le format simple précision pour les variables de type float, double précision pour les variables de type double, et la double précision ou la double précision étendue (suivant le système d'exploitation) pour les variables de type long double. Cependant, si l'extension SSE2 n'est pas utilisée, tous les calculs sont arrondis à la même précision, suivant la configuration de la précision dynamique du processeur (en général, double précision ou double précision étendue, suivant le système d'exploitation, les options de compilation, et les changements effectués par les programmes)
 Ce n’est pas le cas pour PB qui nous fournit  seulement 2 formats un simple et un double précision. En PB si l’on désir utiliser le format flottant sur 80 bits il faut programmer en FASM
En résumer un flottant norme IA32 et IEEE-754 comporte 4 éléments 
1)Un signe (S) sur 1 bit (0 ou 1) 63em bit
2) un exposant (e) non signé  sur 11 bits de 0 à 2^11
3) une mantisse (m) sur 52 bits comprise  de 0 ≤ m < 1 sans le bit implicite et 1 ≤ m <2 avec le bit implicite normalisé
4) Et 1 bit  implicite de poids fort et de valeur 1 ou 0 suivant les valeurs de (e) et de (m) (1 pour les nombre normalisés)
La représentation d’un flottant double précision 64bits sera représenté en machine little indian norme IA32 IEEE-754

0                                                   m           e+m
0         1         2         3         4         5         6   
0123456789012345678901234567890123456789012345678901234567890123
_________________MANTISSE___________________________----EXP----S

 
Toutes les instruction PB de type BIN() Hex() STRx() etc.donnent des représentations en Big Indian 
Les instructions d’un flottant double précision 64bits PB Bin(Valeur.q [,#PB_Quad])  ) 
seront données en Big indian 
e+m         m                                                  0
   6         5         4         3         2         1         0
3210987654321098765432109876543210987654321098765432109876543210
S----EXP----_________________MANTISSE___________________________
Avec m=51 ou 52 bits de mantisse
          e=62  ou 11 bits pour l’exposant
enfin S au 63 em bit codé sur 1 bit valeur 0 ou 1 donc (-1)^S Donne 1 pour S=0 et -1 pout S=1
Pour l’exposant les valeurs binaires ne sont pas des compléments à 2  mais une valeur non signée décalée de (2^(11-1)-1)=$3FF=1023 pour exposant 0  toute valeur supérieure sera positive et toute valeur inférieure sera négative 
Les NaNs et les infinis sont représentés en mettant tous les bits de l'exposant à 1 (2047).ou $7FF
Pour les nombres normalisés, le décalage de l'exposant est +1023. Pour les nombres non normalisés, le décalage de l'exposant est −1022 (l'exposant minimum pour un nombre normalisé. ce n'est pas −1023 car les nombres normalisés ont un 1 avant la virgule, et les nombres non normalisés n'en ont pas. Comme précédemment, zéro et l'infini sont signés.
Remarques :
•	Le plus petit nombre positif différent de zéro, et le plus grand nombre négatif différent de zéro (représentés par une valeur non normalisée avec tous les bits du champ Exposant à 0 et la valeur binaire 1 dans le champ Fraction) sont : ±2^−1074 ≈ ±5×10^−324
•	Le plus petit nombre positif normalisé différent de zéro, et le plus grand nombre négatif normalisé différent de zéro (représentés par la valeur binaire 1 dans le champ Exp, et 0 dans le champ Fraction sont : 
±2^−1022 ≈ ±2,2250738585072020×10^−308
•	Le plus grand nombre positif fini, et le plus petit nombre négatif fini (représenté par la valeur 2046 dans le champ Exp et tous les bits à 1 dans le champ Fraction) sont : 
±(2^1024 − 2^971) ≈ ±1,7976931348623157×10^308
La mantisse codée sur 52 bits Le bit de poids fort de la mantisse est déterminé par la valeur de l'exposant. Si l'exposant est différent de 0 et de 2^e − 1, le bit de poids fort de la mantisse est 1, et le nombre est dit "normalisé". Si l'exposant est nul, le bit de poids fort de la mantisse est nul, et le nombre est 'dé-normalisé'. Il y a trois cas particuliers :
•	si l'exposant et la mantisse sont tous deux nuls, le nombre est ±0 (selon le bit de signe)
•	si l'exposant est égal à 2^11 − 1, et si la mantisse est nulle, le nombre est ±infini (selon le bit de signe)
•	si l'exposant est égal à 2^11 − 1, mais que la mantisse n'est pas nulle, le nombre est NaN (not a number : pas un nombre).

Nous pouvons le résumer ainsi pou un type flottant double précision:
Type                      Exposant            Mantisse        Bit implicite     Valeur centrale
Zéros                        0	                  0	            0	
Nombres non normalisés       0	             différ de 0	      0	             2^(11-1)-2=$3FE
Nombres normalisés       1 à 2^11 − 2        quelconque	        1	              2^(11-1)-1=$3FF
Infinis                    2^11 − 1   	         0	             0	                 Infinty
NaNs                      2^11 − 1           différ de 0	       0	                  NaN

J’ai placé ci-dessous un ensemble de procédures qui permettent de contrôler les représentations en machine
En particulier HEX_VIEW(@val.d,8) qui permet de voir les octets par ordre croissant de l’adresse donc permet d’observer si les données sont en little indian ou en big indian
 La procédure Float_64_bits_Valu(D.D,SIG=0) :qui décompose automatiquement en base 2 
 le flottant double précision en exposant signé et en mantisse signée avec l’instruction ASM 
 fextract; Value in Mantissa (st0) and Exponent (st1)  sortie sous forme  0.xxEee* expo      0.xxEee expression en base 10 expo est en base 2 ce qui donne  val.d=0 .xxEee*(pow(2,expo)
La procédure Float_64_bits_Value(Address.l,sig=0) écrite tout en PB pour mieux comprendre la décomposition
d’un nombre flottant double précision (64bits)
Enfin  la procédure formf(val.D,sig=0)  pour convertir un flottant type .f ou .d qui donne  en sortie une chaîne de forme 0.mmEee  en base 10 utilisable pour affecter une autre variable par vald() ou pour éditer les très grand nombre  par exemple 0 .98765E301 en double précision
Toutes le macros sont là pour faciliter l’édition

le code

Code : Tout sélectionner

Macro _q_t_
  "
EndMacro

Macro _n(__n)
  _q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro

Macro _s(__S)
  _q_t_#__S#=_q_t_+__S+" "
EndMacro
; ;   #PB_Byte   : La valeur est un octet (8 bits) allant de 0 à 255
; ;   #PB_Ascii  : La valeur est un octet (8 bits) allant de 0 à 255
; ;   #PB_Word   : La valeur est un word (16 bits) allant de 0 à 65536
; ;   #PB_Unicode: La valeur est un word (16 bits) allant de 0 à 65536
; ;   #PB_Long   : La valeur est un long (32 bits) allant de 0 à 4294967296
; ;   #PB_Quad   : La valeur est un quad (64 bits) allant de 0 à 18446744073709551615
Macro _f(__F,__nv=8)
  _q_t_#__F#=_q_t_+StrF(__f,__nv)+" "
EndMacro

Macro _d(__D,__nv=8)
  _q_t_#__D#=_q_t_+StrD(__D,__nv)+" "
EndMacro

Macro _Q(__Q)
  _q_t_#__Q#=_q_t_+Str(__Q)+" "
EndMacro

Macro _H(__H,__nv=#PB_Quad,_pr="$")
  _q_t_#__H#=_q_t_+_pr+Hex(__H,__nv)+" "
EndMacro

Macro _B(__B,_pr="%")
  _q_t_#__B#=_q_t_+_pr+Bin(__B)+" "
EndMacro

Macro _U(__U)
  _q_t_#__U#=_q_t_+StrU(__U)+" "
EndMacro

Macro _HW(__HW)
  "$"+RSet(Hex(PeekW(@__HW),#PB_Word),4,"0")
EndMacro

Macro _BW(__BW)
  "%"+RSet(Bin(PeekW(@__BW),#PB_Word),16,"0")
EndMacro

Macro _HL(__HL)
  "$"+RSet(Hex(PeekL(@__HL),#PB_Long),8,"0")
EndMacro

Macro _BL(__BL)
  "%"+RSet(Bin(PeekL(@__BL),#PB_Long),32,"0")
EndMacro

Macro _HQ(__HQ)
  "$"+RSet(Hex(PeekQ(@__HQ),#PB_Quad),16,"0")
EndMacro

Macro _BQ(__BQ)
  "%"+RSet(Bin(PeekQ(@__BQ),#PB_Quad),64,"0")
EndMacro


Macro _Nl
  "N°L="+Str(#PB_Compiler_Line)+" ** "
EndMacro

Macro _Max(__a,__b)
  ((( Not(__a<__b))*__a)+((Not (__a>=__b))*__b))
EndMacro

Macro _Min(__a,__b)
  ((( Not(__a<=__b))*__b)+((Not (__a>__b))*__a))
EndMacro

Macro _Mas(__a,__b)
  (( Not(__a<=__b))*__a)+((Not (__a>=__b))*__b)
EndMacro

Macro _Mis(__a,__b)
  (( Not(__a<=__b))*__b)+((Not (__a>=__b))*__a)
EndMacro
Macro _NEq(A,b)
  (Not(a=B))
EndMacro
Macro _Equ(A,b)
  (Not(a<>B))
EndMacro
Macro _AN_BIS(x): (_Equ((x%4),0) & ((1-_Equ((x%100),0) ) | _Equ(((x>>2)%100),0) ) ):EndMacro
;********************************************
Macro _nbc(__cc)
  __cc.q
  !RDTSC
  PUSH edx
  PUSH eax
  POP dword[v_#__cc]
  POP dword[v_#__cc+4]
EndMacro
Macro _NLE_i(__l_n_t_p)
  DNLE#__l_n_t_p.q
  FNLE#__l_n_t_p.q
  If DNLE#__l_n_t_p=0
    DNLE#__l_n_t_p=ElapsedMilliseconds()
    ;    FNLE#__l_n_t_p=DNLE#__l_n_t_p
    ;  Else
    ;    FNLE#__l_n_t_p=ElapsedMilliseconds()
  EndIf
EndMacro
Macro _NLEx(__tmls)
  "N°L="+Str(#PB_Compiler_Line)+" "+_q_t_ NLE_#__tmls=" +Str(ElapsedMilliseconds() - DNLE#__tmls)+" " : DNLE#__tmls=ElapsedMilliseconds()
EndMacro
Macro _NLC_i(__l_n_c_p)
  DNLC#__l_n_c_p.q
  FNLC#__l_n_c_p.q
  If DNLC#__l_n_c_p.q=0
    DNLC#__l_n_c_p=_nbcs
    ;    FNLC#__l_n_c_p=DNLC#__l_n_c_p
    ;  Else
    ;    FNLC#__l_n_c_p=_nbcs
  EndIf
EndMacro
Macro _NLCx(__tmls)
  "N°L="+Str(#PB_Compiler_Line)+" "+_q_t_ NLC_#__tmls="+StrU(_nbcs() - DNLC#__tmls)+" " : DNLC#__tmls=_nbcs()
EndMacro
Procedure.s hex_viewl(*adres.l,long.l,l1632=16)
  hext$=""
  cart$=""
  For i=0 To long
    num.c=PeekC(*adres+i)
    cart$=cart$+Chr(num)
    hexs.s=Hex(num)+" "
    If Len(hexs)=2
      hexs="0"+hexs
    EndIf
    hext$+hexs
  Next
  If l1632=16
    ProcedureReturn LSet(hext$,50," ")+cart$
  Else
    ProcedureReturn LSet(hext$,100," ")+cart$
  EndIf
EndProcedure
Procedure hex_view(*adress,long)
  long-1
  residu.i=long%16
  ilong=long/16
  Debug "ADRESSE   00_01_02_03_04_05_06_07_08_09_0A_0B_0C_0D_0E_0F       ASCII"
  For i=0 To ilong
    If i=ilong
      Debug "$"+Hex(*adress+(i*16))+"   "+hex_viewl(*adress+(i*16),residu)
    Else
      Debug "$"+Hex(*adress+(i*16))+"   "+hex_viewl(*adress+(i*16),15)
    EndIf
  Next
EndProcedure
Procedure hex_view32(*adress,long)
  long-1
  residu.i=long%32
  ilong=long/32
  Debug "ADRESSE   00_01_02_03_04_05_06_07_08_09_0A_0B_0C_0D_0E_0F 10_11_12_13_14_15_16_17_18_19_1A_1B_1C_1D_1E_1F         ASCII"
  For i=0 To ilong
    If i=ilong
      Debug "$"+Hex(*adress+(i*32))+"   "+hex_viewl(*adress+(i*32),residu,32)
    Else
      Debug "$"+Hex(*adress+(i*32))+"   "+hex_viewl(*adress+(i*32),31,32)
    EndIf
  Next
EndProcedure
; Procedure$ StrE1(fp.d,DCC.b=6)
; Protected E.b
; If DCC<0:DCC=0:ElseIf DCC>20:DCC=20:EndIf;<- Sanity check
; While Abs(fp)>1E1
;   fp*1E-1:E+1
; Wend
; While Abs(fp)<1E-1
;   fp*1E1:E-1
; Wend
; If E:ProcedureReturn StrD(fp,DCC)+"E"+Str(E)
; Else:ProcedureReturn StrD(fp,DCC)
; EndIf
; EndProcedure

; Procedure$ StrE2(fp.d,DCC.b=6)
; Protected E.b
; If DCC<0:DCC=0:ElseIf DCC>20:DCC=20:EndIf;<- Sanity check
; E=Log10(fp)
; If E
;   fp*Pow(10,-E)
;   ProcedureReturn StrD(fp,DCC)+"E"+Str(E)
; EndIf
; ProcedureReturn StrD(fp,DCC)
; EndProcedure
Procedure.S formf(val.D,sig=0)
  If val<0
    sign$=""
    expo10.l=Int(Log10(val*(-1)))+1
  Else
    sign$="+"
    expo10.l=Int(Log10(val))+1
  EndIf
  ms.d=val/Pow(10,expo10)
  If sig=0
    ProcedureReturn StrD(ms,18)+"E"+Str(Expo10)
  Else
    ProcedureReturn sign$+StrD(ms,18)+"E"+Str(Expo10)
  EndIf
EndProcedure
Procedure.s Float_64_bits_Valu(D.D,SIG=0)
  M.d
  E.w
  !fninit                 ;Or Not ;-)
  !fld qword[p.v_D]         ;Load Value
  !fxtract                ;Extract Value in Mantissa (st0) and Exponent (st1)
  !fstp qword[p.v_M]        ;Mantissa
  !fistp word [p.v_E]            ;Exponent
  ;   val.d=m*Pow(2,E)
  mant$=formf(m)
  expo$=Str(e)
  ProcedureReturn mant$+"*"+expo$
  
EndProcedure

Procedure.s Float_64_bits_Value(Address.l,sig=0)
  ; *** recherche du signe
  Sign.q=PeekQ(Address) & $8000000000000000
  If Sign:Sign=-1:Else:Sign=1:EndIf
  ;   Exponant.q=((PeekQ(Address) & $7FF0000000000000)>>52)-1023
  ;*** Recherche de l'exposant
  expow.w=((PeekW(Address+6) & $7FF0)>>4)
  ; *** Recherche de la mantisse
  Mantissa.q=PeekQ(Address) & $000FFFFFFFFFFFFF
  mant.d=mantissa
  DIVx.d=$10000000000000
  fmantissa.d=mant/DIVx
  ; ***** recherche de la valeur du  Bit implicite **********
  If expow=$7FF
    bit.d=0
  Else
    bit.d=1
  EndIf
  If expow=0 ; And mantissa=0
    bit.d=0
  EndIf
  ; ***** recherche des flottants non normalisés **********
  If expow=0 And mantissa<>0
    retr.w=$3FE
    ;     bit.d=0
  Else
    retr.w=$3FF
  EndIf
  
  fmantissa+bit
  exponant.w=expow-retr
  val.d=Sign*Pow(2,Exponant)*fMantissa
  Debug " val="+formf(val)
  If val<0
    sign$=""
    expo10.l=Int(Log10(val*(-1)))+1
  Else
    sign$="+"
    expo10.l=Int(Log10(val))+1
  EndIf
  ms.d=val/Pow(10,expo10)
  If sig=0
    ProcedureReturn StrD(ms,18)+"E"+Str(Expo10)
  Else
    ProcedureReturn sign$+StrD(ms,18)+"E"+Str(Expo10)
  EndIf
EndProcedure
Define d.d,difd.d,q.q,tq.q,mtq.q
Debug "************************************************* Représentation type .W $1357 ***********************"

W.w=$1357
Qq.q
Debug _N(w)+_H(W)
Debug _bw(w)+"  "+_Hw(W)
hex_view(@w,2)
Debug "************************************************* Représentation type .L $12345678 ***********************"
L.l=$12345678
qq.q
Debug _N(l)+_H(l)
Debug _bl(l)+"  "+_HL(l)
hex_view(@l,4)
Debug "************************************************* Représentation type .Q $123456789ABCDEF ***********************"
Q.Q=$123456789ABCDEF
QQ.Q
Debug _N(q)+" "+_Hq(q)
Debug " bin="+_bq(q)+"  hex="+Hex(q)
Debug "  bin="+Bin(q,#PB_Quad)
hex_view(@q,8)
titre$= "************************************************ Représentation type .Double float de ZERO +0           ***********************"
d=-0
Gosub edit
titre$= "************************************************ Représentation type .Double float de UN 1             ***********************"
d=1
Gosub edit
titre$= "************************************************ Représentation type .Double float de UN -1             ***********************"
d=-1
Gosub edit
titre$= "************************************************ Représentation type .Double float de deux 2            ***********************"
d=2
Gosub edit
titre$= "************************************************ Représentation type .Double float de deux -2           ***********************"
d=-2
Gosub edit
titre$= "************************************************ Représentation type .Double float de $7FFFFFFFFFFFFdFF ***********************"
q.q=$7FFFFFFFFFFFFdFF
d=q
Gosub edit
titre$= "************************************************ Représentation type .Double float de -$7FFFFFFFFFFFFdFF ***********************"
d=-D
Gosub edit
titre$= "************************************************ Représentation type .Double float de  3.14159E331       ***********************"
d=3.14159E301
Gosub edit
End
EDIT:
Debug " "
Debug "*******************************************************************************************************************************"
Debug titre$
Debug "*******************************************************************************************************************************"
Debug "*** la représentation hexa suivante est en little indian utilisé par Intel ***"
Debug "*** LES poids de chiffres LES plus forts en dernier exemple $03FF s'écrit FF03 ***"

hex_view(@d,8)
Debug "*** Les représentations qui suivent sont en BIG indian comme la notation des nombres en langue latine"
Debug "*** LES poids de chiffres LES plus forts en premier exemple cent trente quatre s'écrit 134 ***"

Debug "FLOAT Hex="+_HQ(d)+" FLOAT bin="+_BQ(D)
Debug "                                       S----EXP----_________________MANTISSE___________________________"

Debug "                                       ____----____----____----____----____----____----____----____---- 1/2 octet"
Debug " ** Décomposition en mantisse signée sous forme S*mant*puissance de 10 et l'exposant en puissace de 2 **"
mant.d=ValD(StringField(Float_64_bits_Valu(d),1,"*"))
Ex.w=Val(StringField(Float_64_bits_Valu(d),2,"*"))
Debug "MANTISSE="+_bq(mant)+" MANT="+_d(mant)
Debug " expo bin="+_bw(ex)+" hex="+Hex(ex,#PB_Word)+" "+_Hw(ex)+" "+_n(ex)+" Valeurs en base 2 donc Mant*POW(2,ex)"
Debug formf(mant*Pow(2,Ex))+" ** Valeur retrouvée en appliquant val=mant*Pow(2,Ex)"
Return

[Frenchy Pilou]

L'importance du traitement des exceptions est parfaitement illustrée par le crash du vol
501 d'Ariane en 1996, qui a coûté quelques 500 millions de dollars.

Y a même pas besoin d'aller chercher si profond
Rien qu'entre les systèmes d'unités c'est déjà le bazar
Mars orbiter 900 millions de dollars