PureBasic Forums - English

Code: Select all

Structure single_TYPE
  StructureUnion
    flt.f
    int.l
    cha.b[4]
  EndStructureUnion
EndStructure

sng.single_TYPE

Procedure.s zLeft(valu,dgt)
  ProcedureReturn Right("00000000000000000000000000000000000000000000000000000000000000000"+Bin(valu),dgt)
EndProcedure

; Format of a 32 bit IEEE-754 float;
; Bits: Seeeeeee eMMMMMMM MMMMMMMM MMMMMMMM
; Where S = Sign
;       e = exponent
;       M = Mantissa (or fraction or significand, your call)

Procedure calcIEEEsingle(vlu.f)
  
  Debug ""
  Debug "-------------------"
  Debug "ORIGINAL = " + StrF(vlu)
  Debug ""
  
  ;Stick the original value into our structure
  sng.single_TYPE\flt=vlu
  
  ; Because of endian-ness, use reverse order
  ;  in processing the 4 bytes

  signIs=(sng\cha[3] & $80) >> 7
  If signIs
    signIs=-1
    Debug "Value is NEGATIVE"
  Else
    signIs=1
    Debug "Value is POSITIVE"
  EndIf
  
  ;Next 8 bits are the exponent.
  ; Need to give them a little shift to the left
  exponent=((sng\cha[3] & $7F) << 1) + ((sng\cha[2] & $80) >> 7)
  Debug "Raw exponent = "+Bin(exponent)
  
  ;Mantissa is next 23 bits (base 2)
  ; Do some shuffle, using several code lines for readability.
  mantissa=(sng\cha[2] & $7F) : mantissa << 8
  mantissa+(sng\cha[1] & $FF) : mantissa << 8
  mantissa+(sng\cha[0] & $FF) : mantissa * 2
  
  Debug "Raw Mantissa = "+zLeft(mantissa,24)+" ("+Str(mantissa)+")"
  Debug "This is ..."
  If exponent=255 And mantissa<>0
    Debug "... NaN"
  ElseIf exponent=255 And mantissa=0
    If signIs=-1
      Debug "... Negative Infinity"
    Else
      Debug "... Infinity"
    EndIf
  ElseIf exponent=0 And mantissa=0
    If signIs=-1
      Debug "... Negative zero (-0)"
    Else
      Debug "... Zero"
    EndIf
  ElseIf exponent=0 And mantissa<>0
    Debug "... a Denormalised number"
  Else
    Debug "... a Normalised number"
    
    ; Calculate the mantissa as a "binary decimal"
    man.f=1.0                    ; There is an invisible or implied one
    flag=$00800000               ; This flag used to check the bits
    adj.f=1.0                    ; This value halved for each bit
    
    For i=1 To 23                ; Check each bit for mantissa bits
      adj / 2.0                  ;   Halve our value
      If mantissa & flag         ;   If the bit is set
        man + adj                ;     add value to mantissa
      EndIf                      ;
      flag >> 1                  ; Shift the bit one place right
    Next                         ;
    
    ; Test the result:
    ;    Note -  exponent here adjusted by -127 (the "bias")
    ;    However, this should be checked earlier as it can
    ;             change this, for example whether the
    ;            "decimal binary" starts with 1. or 0.
    ; But who cares!

    ; Make everything a float.
    ; Not absolutely needed, but ...
    fSign.f = signIs
    fExp.f = exponent
    
    IEEE754val.f= fSign * Pow(2.0,(fExp-127.0)) * man
    Debug StrF(IEEE754val) + " is the IEEE-754 value"
    Debug StrF(vlu) + " is the original value."
  EndIf
EndProcedure

odds.single_TYPE

odds\int=$0        : calcIEEEsingle(odds\flt)
odds\int=$80000000 : calcIEEEsingle(odds\flt)
odds\int=$7F800000 : calcIEEEsingle(odds\flt)
odds\int=$FF800000 : calcIEEEsingle(odds\flt)
odds\int=$80       : calcIEEEsingle(odds\flt)

calcIEEEsingle(1.0)
calcIEEEsingle(-1.0)
calcIEEEsingle(123.45)
calcIEEEsingle(-123.45)
calcIEEEsingle(0.1)
calcIEEEsingle(-0.1)
calcIEEEsingle(1.0/3.0)
calcIEEEsingle(22.0/7.0)
calcIEEEsingle(123.456)
calcIEEEsingle(123.4567)