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
