hamming.py

import numpy as np

def redo_change(split_binary_message):
    message = ''    
    for i in range(0, len(split_binary_message), 2):
        block1 = split_binary_message[i]
        block2 = split_binary_message[i + 1] if i + 1 < len(split_binary_message) else [0, 0, 0, 0]

        # Unir bloques de cuatro bits en uno de ocho bits
        combined_block = block1 + block2

        # Convertir el bloque de ocho bits a su valor de carácter
        char_value = chr(int(''.join(map(lambda x: str(int(float(x))), combined_block)), 2))
    
        # Agregar el valor de carácter al mensaje final
        message += char_value
    return message

def four_bits_block(binary_message):
    split_binary_message = []
    for block in binary_message:
        # Dividimos cada bloque de ocho bits en dos de cuatro bits
        first_four_bits = block[:4]
        second_four_bits = block[4:]
        # Convertir cada bloque de cuatro bits a una lista de enteros
        first_four_bits_int = [int(bit) for bit in first_four_bits]
        second_four_bits_int = [int(bit) for bit in second_four_bits]
        # Agregar las listas de enteros a la lista principal
        split_binary_message.extend([first_four_bits_int, second_four_bits_int])
    return split_binary_message

def encode(block, G):
    # Encriptamos el bloque al multiplicarlo con la matriz generadora
    # La multiplicación se realiza en módulo dos
    block = np.dot(block, G) % 2
    # Introducimos errores al bloque encriptado
    bit_to_flip = np.random.randint(0, len(block))
    block[bit_to_flip] = 1 - block[bit_to_flip]
    # Retornamos
    return block

def decode(block, H):
    # Obtenemos la transpuesta de la matriz de paridad
    H_transpuesta = np.transpose(H)
    # Obtenemos el sindrome (matriz binario)
    sindrome = np.dot(block, H_transpuesta) % 2
    # Convertir el array de NumPy a una lista de Python
    sindrome_list = sindrome.tolist()
    # Obtenemos el valor decimal del sindrome
    sindrome_decimal = int(''.join(map(lambda x: str(int(float(x))), sindrome_list)), 2)
    # Obtenemos el indice donde se encuentra el error
    index_error = sindrome_decimal - 1
    # Corregimos el error
    if (index_error >= 0): 
        block[index_error] = 1 - block[index_error]
    # Retornamos
    return block

############################################################## MAIN #########################################################################


# Definimos tanto la matriz de paridad como la matriz generadora
H = np.array([ [1, 0, 1, 0, 1, 0, 1],
               [0, 1, 1, 0, 0, 1, 1],  
               [0, 0, 0, 1, 1, 1, 1] ])

G = np.array([ [1, 1, 1, 0, 0, 0, 0],
               [1, 0, 0, 1, 1, 0, 0],
               [0, 1, 0, 1, 0, 1, 0],
               [1, 1, 0, 1, 0, 0, 1] ])

# Obtenemos la representación binaria de un mensaje
message = "Hello!"
binary_message = [format(ord(caracter), '08b') for caracter in message]

# Dividimos cada caracter de ocho bits en bloques de cuatro bits. 
# Estamos trabajando con un Hamming(4, 7)
split_binary_message = four_bits_block(binary_message)

# Iteramos sobre los bloques
for block in split_binary_message:
    # Encriptamos
    block = encode(block, G)
    
    # Desencriptamos
    block = decode(block, H)

# Rehacemos los cambios realizados sobre el mensaje
message = redo_change(split_binary_message)

print(message)