Convertidor de decimal a IEEE754 en python

decimal_to_ieee754.py

def decimal_to_ieee754(decimal):
    # Separar la parte entera y fraccionaria
    entero = abs(int(decimal))
    fraccion = abs(decimal) - entero
    # Convertir la parte entera a binario
    binario_entero = ''
    binario_fraccion = ''
    exponente = 0
    signo = 0
    mantisa = ''
    if decimal < 0:
        signo = 1
    if entero == 0:
        binario_entero = '0' 
    else:
        binario_entero = ''
        i = 1
        while entero > 0 and i <= 127:
            binario_entero = str(entero % 2) + binario_entero
            print(f"Entero actual: {entero:<6}  Binario entero: {binario_entero:>11}")
            entero //= 2
            i += 1
    # Vemos si hay un 1 en la parte entera
    primer_uno_index = binario_entero.find('1')
    # Si lo hay entonces calculamos cuanto es lo restante de 
    # mantisa
    if primer_uno_index != -1:
        # Si existe un 1 en la parte entera entonces
        # calculamos cuanto es lo que queda de mantisa 
        # disponible para la parte fraccionaria 
        binario_entero = binario_entero[primer_uno_index:]
        tamano_maximo_fraccion = 23 - len(binario_entero) + 1
        exponente = len(binario_entero) - 1 
    else:
        # Si no habia un 1 en la parte entera entonces buscamos 
        # el primero en la parte fraccionaria
        # Convertimos la parte fraccionaria hasta encontrar el 
        # primer uno
        primer_uno_encotrado = False
        i = 1
        while primer_uno_encotrado == False and i <= 126:
            fraccion *= 2
            bit = int(fraccion)
            binario_fraccion += str(bit)
            print(f"Fracción actual: {format(round(fraccion,2), ".2f")}, Binario fracción: {binario_fraccion}")
            fraccion -= bit
            if bit == 1:
                primer_uno_encotrado = True
                break
            i += 1
        exponente = -i
        if i == 127:
            # Caso para detectar posible subnormal (posible porque puede ser 0)
            # Se da la oportunidad de que el 1 se ubique 23 posciciones a la izquerda del 0
            # para la representacion minima de 2**-149
            print("Posible subnormal detectado")
            i = 1
            while i <= 23:
                fraccion *= 2
                bit = int(fraccion)
                binario_fraccion += str(bit)
                print(f"Fracción actual: {format(round(fraccion,2), ".2f")}, Binario fracción: {binario_fraccion}")
                fraccion -= bit
                if bit == 1:
                    primer_uno_encotrado = True
                    break
                i += 1
            if primer_uno_encotrado == True:
                # Si se encontro un 1 en la parte fraccionaria
                # entonces es un numero subnormal
                print("Numero subnormal confirmado")
                exponente = -127
                mantisa = binario_fraccion[-23:]
                exponente_sesgado = exponente + 127
                return (signo, exponente_sesgado, mantisa)
            

        if primer_uno_encotrado == False:
            #Si no se logro encontrar un primer uno en la parte
            #fraccionaria, entonces se aproxima a zero
            print("No se encontro un 1 en la parte fraccionaria")
            print("Numero aproximado a cero")
            exponente = -127
            mantisa = '00000000000000000000000'
            exponente_sesgado = exponente + 127
            return (signo, exponente_sesgado, mantisa)
        
        # Luego si el numero no es un subnormal, pero no tiene parte entera
        # entonces se buscan los 23 bits restantes 
        i = 1
        while i <= 23:
            fraccion *= 2
            bit = int(fraccion)
            binario_fraccion += str(bit)
            print(f"Fracción actual: {format(round(fraccion,2), ".2f")}, Binario fracción: {binario_fraccion}")
            fraccion -= bit
            i += 1
        binario_completo = binario_fraccion[-23:]
        mantisa = binario_fraccion[-23:]
        exponente_sesgado = exponente + 127
        return (signo, exponente_sesgado, mantisa)
    
    # Si el numero es normalizado y tiene parte entera 
    # terminamos de buscar los siguientes valores para la mantisa
    i = 1
    while i <= tamano_maximo_fraccion:
        fraccion *= 2
        bit = int(fraccion)
        binario_fraccion += str(bit)
        print(f"Fracción actual: {format(round(fraccion,2), ".2f")}, Binario fracción: {binario_fraccion}")
        fraccion -= bit
        i += 1

    binario_completo = binario_entero[1:] + binario_fraccion
    mantisa = binario_completo
    exponente_sesgado = exponente + 127
    return (signo, exponente_sesgado, mantisa)
    

lista_decimales = [23.7890065]
for decimal in lista_decimales:
    print("--------------------------------")
    print(f"\nConvertiendo el decimal: {decimal}")
    signo, exponente_sesgado, mantisa = decimal_to_ieee754(decimal)
    representacion_binaria = f"{signo}{bin(exponente_sesgado)[2:].zfill(8)}{mantisa}"
    representacion_hex = hex(int(representacion_binaria, 2))
    print(f"Signo: {signo}, Exponente sesgado: {exponente_sesgado}, Mantisa: {int(mantisa, 2)}")
    print(f"IEEE 754 Representation en binario: {representacion_binaria}")
    print(f"IEEE 754 Representation en hex: {representacion_hex}")