task3_4.py - master - ku11ch/Lab_3

task3_4.py
125 строк5 KB
ku11ch
upload files
14 окт 2025, 10:54
14 окт 2025, 10:5424ce3ca
# Инверсный код

import random


class InverseCode:
    @staticmethod
    def encode(data):
        return (data, ~data & ((1 << data.bit_length()) - 1))

    @staticmethod
    def decode(original_data, inverse_data):
        # Проверяем, что inverse_data действительно инверсные к original_data
        expected_inverse = ~original_data & ((1 << original_data.bit_length()) - 1)
        return inverse_data == expected_inverse

    @staticmethod
    def introduce_errors(encoded_data, error_probability=0.1):
        original, inverse = encoded_data

        # Вносим ошибки в оригинальные данные
        corrupted_original = original
        for i in range(original.bit_length()):
            if random.random() < error_probability:
                corrupted_original ^= (1 << i)

        # Вносим ошибки в инверсные данные
        corrupted_inverse = inverse
        for i in range(inverse.bit_length()):
            if random.random() < error_probability:
                corrupted_inverse ^= (1 << i)

        return (corrupted_original, corrupted_inverse)

    @staticmethod
    def calculate_detection_probability(data, error_probability=0.1, num_tests=1000):
        encoded = InverseCode.encode(data)
        n = data.bit_length()
        detected_errors = 0
        total_tests = 0

        for _ in range(num_tests):
            # Вносим ошибки
            corrupted = InverseCode.introduce_errors(encoded, error_probability)

            # Проверяем корректность
            if not InverseCode.decode(corrupted[0], corrupted[1]):
                detected_errors += 1

            total_tests += 1

        return detected_errors / total_tests if total_tests > 0 else 0.0

    @staticmethod
    def get_code_parameters(data_length):
        total_bits = data_length * 2  # оригинал + инверсная копия
        return {
            'data_length': data_length,
            'total_bits': total_bits,
            'redundancy': 0.5,  # 50% избыточность
            'theoretical_detection': 1 - (1 - 0.1) ** (data_length / 2)
        }


def demonstrate_inverse_code():
    """Демонстрация работы инверсного кода"""
    print("=== Инверсный код ===")

    # Тестовые данные
    test_data = 0b11001010  # 202 в десятичной
    print(f"Исходные данные: {bin(test_data)} (десятичное: {test_data})")

    # Кодирование
    original, inverse = InverseCode.encode(test_data)
    print(f"Оригинальные данные: {bin(original)}")
    print(f"Инверсные данные: {bin(inverse)}")

    # Проверка корректности
    is_valid = InverseCode.decode(original, inverse)
    print(f"Проверка корректности (должно быть True): {is_valid}")

    # Внесение ошибок
    corrupted_original = original ^ 0b00010000  # Инвертируем один бит
    print(f"\nПосле внесения ошибки в оригинал:")
    print(f"Оригинал с ошибкой: {bin(corrupted_original)}")
    print(f"Инверсные данные: {bin(inverse)}")
    print(f"Обнаружена ошибка: {not InverseCode.decode(corrupted_original, inverse)}")

    # Внесение ошибок в инверсные данные
    corrupted_inverse = inverse ^ 0b00010000
    print(f"\nПосле внесения ошибки в инверсные данные:")
    print(f"Оригинальные данные: {bin(original)}")
    print(f"Инверс с ошибкой: {bin(corrupted_inverse)}")
    print(f"Обнаружена ошибка: {not InverseCode.decode(original, corrupted_inverse)}")

    # Коэффициент обнаружения ошибок
    p_error = 0.1
    detection_prob = InverseCode.calculate_detection_probability(test_data, p_error, 2000)

    params = InverseCode.get_code_parameters(test_data.bit_length())
    theoretical_prob = 1 - (1 - p_error) ** (test_data.bit_length() / 2)

    print(f"\nКоэффициент обнаружения ошибок (p={p_error}):")
    print(f"Теоретический: {theoretical_prob:.4f}")
    print(f"Экспериментальный: {detection_prob:.4f}")

    # Сравнение с другими методами
    print(f"\nПараметры кода:")
    for key, value in params.items():
        print(f"  {key}: {value}")

    # Тестирование на различных данных
    print("\nТестирование на различных данных:")
    test_cases = [0b10101010, 0b11110000, 0b00001111, 0b01010101]

    for data in test_cases:
        encoded = InverseCode.encode(data)
        # Вносим ошибку
        corrupted = (encoded[0] ^ 0b00100000, encoded[1])
        is_error_detected = not InverseCode.decode(corrupted[0], corrupted[1])
        print(f"Данные {bin(data)} -> Ошибка обнаружена: {is_error_detected}")


if __name__ == "__main__":
    demonstrate_inverse_code()