def test_code(self): config = yaml.safe_load(open('config-test.yml')) for i in range(2 ** self.k): code, distorted_code, error = encode( coder_file=config['coder-generator-test'], message=i, m_length=self.k, error=74) # 000000000000001001010 assert transpose_matrix( matrix=multiply_matrices( matrix1=read_file_to_list(config['decoder-parity-check-test']), columns_count1=self.n, matrix2=transpose_matrix([code], self.n), columns_count2=1 ), columns_count=1)[0] == 0 for i in range(2 ** self.k): code, distorted_code, error = encode( coder_file=config['coder-generator-test'], message=i, m_length=self.k) if get_hamming_weight(error) <= self.t: assert transpose_matrix( matrix=multiply_matrices( matrix1=read_file_to_list(config['decoder-parity-check-test']), columns_count1=self.n, matrix2=transpose_matrix([code], self.n), columns_count2=1 ), columns_count=1)[0] == 0
def test_fill_parity_check_matrix_and_a_matrix_transposed(self): parity_check_matrix, a_matrix_transposed = fill_parity_check_matrix_and_a_matrix_transposed( n=self.n, r=self.r, d=self.d) for line in parity_check_matrix: assert line != 0 for line in a_matrix_transposed: assert get_hamming_weight(line) >= self.d - 1
def test_find_linearly_independent_vector(self): assert is_gilbert_varshamov_bound(n=self.n, k=self.k, d=self.d) i_matrix = fill_i_matrix(size=self.r) for i in range(1000): result = find_linearly_independent_vector( vector_pool=i_matrix, number_of_columns_v_p=self.r, linear_combination_size=self.d - 2) assert get_hamming_weight(num=result) >= self.d - 1
def test_get_random_number_of_hamming_weight(self): for i in range(100): length = random.randrange(100) if length == 0: continue weight = random.randrange(length) probe = get_random_number_of_hamming_weight(length=length, weight=weight) assert get_hamming_weight(num=probe) == weight
def test_generator_matrix_from_a_matrix_transposed(self): n = 10 k = 3 r = n - k d = 1 parity_check_matrix, a_matrix_transposed = fill_parity_check_matrix_and_a_matrix_transposed( n=n, r=r, d=d) for i in fill_generator_matrix_from_a_matrix_transposed( a_matrix_transposed=a_matrix_transposed, k=k, r=r): assert get_hamming_weight(i) >= d
def test_f_l_i_v_inner_loop(self): linear_combination_size = self.d - 2 combinations_v_p = [] vector_pool = fill_i_matrix(size=self.r) for i in range(linear_combination_size): combinations_v_p.append(list(combinations(vector_pool, i + 1))) test_value = 4378 # 1000100011010 assert get_hamming_weight(num=test_value) < self.d - 1 for i in range(1000): assert f_l_i_v_inner_loop( probe=test_value, combinations_v_p=combinations_v_p) != test_value
def test_generate_a_matrix_and_a_matrix_transposed(self): h_matrix, g_matrix, a_matrix_transposed = get_source_matrices( r=self.r, d=self.d, k=self.k) print("\r\nH matrix: ", h_matrix) print("G matrix: ", g_matrix) print("Transposed matrix: ", a_matrix_transposed) linear_row = [(row != 0) for row in h_matrix] bound_hamming_weight = [(get_hamming_weight(i) >= self.d - 1) for i in a_matrix_transposed] assert len(linear_row) != 0 assert len(bound_hamming_weight) != 0
def test_get_binary_numbers_partitioned_by_weight(self): n = 127 length = len(bin(n)) - 2 binary_numbers_partitioned_by_weight = partition_binary_numbers_by_weight( num=n) weight = 0 for i in binary_numbers_partitioned_by_weight: if weight != get_hamming_weight(i): weight += 1 assert weight <= length sorted_list_of_numbers = sorted(binary_numbers_partitioned_by_weight) for i in range(n): assert sorted_list_of_numbers[i] == i
def test_generate_syndrome_decoding_table(self): n = 6 r = 3 k = n - r d = 1 h_matrix, g_matrix, a_matrix_transposed = get_source_matrices(r=r, d=d, k=k) assert len(h_matrix) != 0 assert len(g_matrix) != 0 assert len(a_matrix_transposed) != 0 syndrome_decoding_table = generate_syndrome_decoding_table( g_matrix=g_matrix, h_matrix=h_matrix, n=n, k=k, d=d) for key in syndrome_decoding_table.keys(): if key != 0: for word in syndrome_decoding_table[key]: assert get_hamming_weight(word) <= self.t assert word != 0
def test_generate_syndrome_decoding_table(self): n = 6 r = 3 k = n - r d = 1 parity_check_matrix, a_matrix_transposed = fill_parity_check_matrix_and_a_matrix_transposed( n=n, r=r, d=d) generator_matrix = fill_generator_matrix_from_a_matrix_transposed( a_matrix_transposed=a_matrix_transposed, k=k, r=r) syndrome_decoding_table = generate_syndrome_decoding_table( generator_matrix=generator_matrix, parity_check_matrix=parity_check_matrix, n=n, k=k, d=d) for key in syndrome_decoding_table.keys(): if key == 0: continue for word in syndrome_decoding_table[key]: assert get_hamming_weight(word) <= self.t assert word != 0
def test_code_decode(self): config = yaml.safe_load(open('config-test.yml')) number_of_unfixed_errors = 0 number_of_repetitions = 100 for i in range(number_of_repetitions): message = random.randrange(2 ** self.k) rand_error = get_hamming_weight(self.n, int((self.d - 1) / 2)) code, distorted_code, error = encode( coder_file=config['coder-generator-test'], message=message, m_length=self.k, error=rand_error) assert rand_error == error decoded = decode( parity_check_file=config['decoder-parity-check-test'], n=self.n, syndrome_file=config['syndrome-decoding-test'], distorted_code=distorted_code ) if decoded != message: number_of_unfixed_errors += 1 assert number_of_unfixed_errors == 0
def test_get_hamming_weight(self): assert get_hamming_weight(num=7) == 3 assert get_hamming_weight(num=8) == 1 assert get_hamming_weight(num=1) == 1