Wie Mantisse in Python zu berechnen, wenn der Exponent Hit auf -127

Question

Ich habe eine Standortinformation in HEX Zeichenfolge. Ich muss es in IEEE-754-Protokoll in Floating-Integer konvertieren.

Also schrieb ich diesen Code Zeichen der Zahl zu finden, berechnen Exponenten und Mantisse aus binärer Darstellung der Hexadezimalzahl angegeben.

def _calculte_mantissa(bin_number): 
    val = 1 
    bit_count = -1 
    bit_length = 0 
    while bit_length <= 22: 
     print bit_count, bit_length 
     val += int(bin_number[bit_length]) * 2**bit_count 
     bit_count -= 1 
     bit_length += 1 
     print val 
    return val 

def convert_position(pos): 
    bin_pos = format(int(pos, 16), "0>32b") 
    sign = (-1)**int(bin_pos[0], 2) 
    exponent = int(bin_pos[1:9], 2) - 127 
    mantissa = _calculte_mantissa(bin_pos[9:]) 
    position = sign * 2**exponent * mantissa 
    return position 

Das Problem ist; Wenn der Exponent kleiner als -126 ist, also -127, ist das Ergebnis nicht korrekt. Ich überprüfe das Ergebnis from this address, Zeichen und Exponent Ergebnisse sind korrekt, aber Mantisse Ergebnis ist anders als meins.

ich etwas über das fehle, was die Seite sagt:

Als Ergebnis weist der Mantisse einen Wert zwischen 1,0 und 2. Wenn der Exponent -127 (binär 00000000) erreicht, wird die führende 1 wird nicht mehr verwendet, um allmählichen Unterlauf zu ermöglichen.

Jede Art, wie ich das Problem kenne hier ist aber kann ich wegen meines unzureichend Englisch nicht herausgefunden.

Answer 1

Nach Vorschlag von @Rudy Velthuis habe ich herausgefunden, dass ich 1.0 entfernen und mit Exponent -126 berechnen muss, wenn der Exponent auf -127 trifft. So ist das Ergebnis:

#! /usr/bin/env python 
# -*- coding: utf-8 -*- 
import sys 


def _calculte_mantissa(bin_number, exponent): 
    val = 1 if exponent > -127 else 0 
    bit_count = -1 
    bit_length = 0 
    while bit_length <= 22: 
     val += int(bin_number\[bit_length\]) * 2**bit_count 
     bit_count -= 1 
     bit_length += 1 
    return val 


def convert_ieee754(hex_val): 
    bin_pos = format(int(hex_val, 16), "0>32b") 
    sign = (-1)**int(bin_pos\[0\], 2) 
    _exponent = int(bin_pos\[1:9\], 2) - 127 
    mantissa = _calculte_mantissa(bin_pos\[9:\], _exponent) 
    exponent = _exponent if _exponent > -127 else -126 
    position = sign * 2**exponent * mantissa 
    return "Bin: %s - Sign: %s - Exponent: %s (%s) - Mantissa: %s - Posititon: %s" % (bin_pos, sign, exponent, 
                         _exponent, mantissa, position) 


if __name__ == "__main__": 
    argvs = sys.argv 
    print convert_ieee754(argvs\[1\]) 
    sys.exit() 

https://github.com/RecNes/Python-IEEE754-Calculator-with-Denormalized-Values/blob/master/ieee754.py

Answer 2

Diese Methode funktioniert für mich und ich konsequent die gleiche Leistung aus Ihrem Skript:

import struct 
def ieee754(value): 
    packed_v = struct.pack('>l', value) 
    return struct.unpack('>f', packed_v)[0] 

>>> ieee754(0x436be878) 
235.9080810546875