def checker(group, student, task_code):
fname = f'{student}_{task_code}_{group}.xlsx'
print(f'\n')
print(f'*********************')
print(f'Чтение файла {fname}')
try:
wb = load_workbook(fname)
except FileNotFoundError:
print(f'Файл {fname} не найден')
return
ws = wb['Main']
G = []
for row in ws.iter_rows(min_row=1,
max_col=max_n,
max_row=2 + max_k,
values_only=True):
row = list(filter(None.__ne__, row)) # Убирает ненужные None
g_Ok = is_bits_vector(row)
nr = len(row)
if g_Ok and nr >= min_n and nr <= max_n:
G.append(row) # Читаем матрицу кода
k, n, ok = lc.check_matrix(G)
r = n - k
assert (ok)
print(f'Порождающая матрица ({n}, {k})-кода')
pp(G)
parameters = []
H_ = []
wsC = wb['Check']
for row in wsC.iter_rows(min_row=1,
max_col=max_n,
max_row=5 + max_n - min_k,
values_only=True):
row = list(filter(None.__ne__, row)) # Убирает ненужные None
h_Ok = is_bits_vector(row)
nr = len(row)
if h_Ok and nr >= min_n and nr <= max_n:
H_.append(row) # Читаем матрицу кода
elif nr == 1 and isinstance(row[0], int):
parameters.append(row[0])
r_, n_, ok = lc.check_matrix(H_)
k_ = n_ - r_
assert (r_ == r)
assert (n_ == n)
assert (ok)
assert (sum(map(sum, H_)) > 0)
assert ((len(parameters) == 1))
d_ = parameters[0]
print(f'Идет вычисление кодового расстояния d...', flush=True)
Wsp = lc.gen_spectrum(G)
d = lc.spectrum_to_code_distance(Wsp)
print(f'd = {d}', flush=True)
print(f'Идет подбор проверочной матрицы H...', flush=True)
H = lc.get_check_matrix(G)
print(f'Идет вычисление кодового расстояния d по H...', flush=True)
d_alter = lc.get_code_distance(H, False)
print(f'Правильные ответы:')
print(f'd = {d}, альтернативный метод d = {d_alter}')
assert (d == d_alter)
print(f'Введенные ответы:')
pp(f'd = {d_}')
assert (d_ == d)
print(f'Правильная проверочная матрица кода')
pp(H)
print(f'Введенная проверочная матрица кода')
pp(H_)
zero = sum(map(sum, lc.mult_M(G, lc.transpose(H))))
zero_ = sum(map(sum, lc.mult_M(G, lc.transpose(H_))))
print(f'Контроль правильности проверочной матрицы')
ok = (zero == zero_ == 0)
pp(ok)
assert (ok)
pp('All Ok')
def checker(group, student, task_code):
fname = f'{student}_{task_code}_{group}.xlsx'
print(f'\n')
print(f'*********************')
print(f'Чтение файла {fname}')
try:
wb = load_workbook(fname)
except FileNotFoundError:
print(f'Файл {fname} не найден')
return
ws = wb['Main']
G = []
for row in ws.iter_rows(min_row=1,
max_col=max_n,
max_row=4 + max_k,
values_only=True):
row = list(filter(None.__ne__, row)) # Убирает ненужные None
g_Ok = is_bits_vector(row)
n_row = len(row)
if g_Ok and n_row >= min_n and n_row <= max_n:
G.append(row) # Читаем матрицу кода
# В конце считанной матрицы принятый кодовый вектор
v = G.pop()
print('Принятый кодовый вектор')
pp(v)
k, n, ok = lc.check_matrix(G)
r = n - k
assert (ok)
print('Порождающая матрица кода')
pp(G)
parameters = []
H_ = []
wsC = wb['Check']
for row in wsC.iter_rows(min_row=1,
max_col=max_n,
max_row=5 + max_n - min_k,
values_only=True):
row = list(filter(None.__ne__, row)) # Убирает ненужные None
h_Ok = is_bits_vector(row)
n_row = len(row)
if h_Ok and n_row >= min_n and n_row <= max_n:
H_.append(row) # Читаем матрицу кода
elif n_row == 1 and isinstance(row[0], int):
parameters.append(row[0])
r, n, ok = lc.check_matrix(H_)
k = n - r
assert (ok)
assert (sum(map(sum, H_)) > 0)
assert ((len(parameters) == 1))
d_ = parameters[0]
Wsp = lc.gen_spectrum(G)
d = lc.spectrum_to_code_distance(Wsp)
print('Подождите идет подбор матрицы H...')
H = lc.get_check_matrix(G)
d_alter = lc.get_code_distance(H, False)
print('Правильные ответы:')
pp(f'd = {d}, альтернативный метод d = {d_alter}')
assert (d == d_alter)
print('Введенные ответы:')
pp(f'd = {d_}')
assert (d_ == d)
print('Правильная проверочная матрица кода')
pp(H)
print('Введенная проверочная матрица кода')
pp(H_)
zero = sum(map(sum, lc.mult_M(G, lc.transpose(H))))
zero_ = sum(map(sum, lc.mult_M(G, lc.transpose(H_))))
print('Контроль правильности проверочной матрицы')
ok = (zero == zero_ == 0)
pp(ok)
assert (ok)
wsV = wb['CodeVector']
s_ = []
a_ = []
for row in wsV.iter_rows(min_row=1,
max_col=max_n,
max_row=6,
values_only=True):
row = list(filter(None.__ne__, row)) # Убирает ненужные None
g_Ok = is_bits_vector(row)
n_row = len(row)
if g_Ok and n_row >= min_n and n_row <= max_n:
s_.append(row) # Читаем декодированный кодовый вектор
if g_Ok and n_row >= min_k and n_row <= max_k:
a_.append(row) # Читаем декодированный информационный вектор
assert (len(s_) == 1)
assert (len(a_) == 1)
s_ = s_[0]
a_ = a_[0]
n_ = len(s_)
k_ = len(a_)
assert (n_ == n)
assert (k_ == k)
ac = lc.get_min_adjacent_classes(H)
c = lc.mult_v(v, lc.transpose(H))
e = ac[tuple(c)]
s_est = lc.xor(v, e)
print('Скорректированный кодовый вектор')
pp(s_est)
print('Синдром')
pp(c)
print('Вектор ошибки минимальной кратности')
pp(e)
print('Введенный скорректированный кодовый вектор')
pp(s_)
zero = sum(lc.mult_v(s_est, lc.transpose(H)))
zero_ = sum(lc.mult_v(s_, lc.transpose(H_)))
assert (zero == zero_ == 0)
e_ = lc.xor(v, s_)
qe = lc.hamming_weight(e)
qe_ = lc.hamming_weight(e_)
assert (qe == qe_)
print('Найденный вектор ошибки наименьшей кратности')
pp(e)
print('Кратность')
pp(qe)
print('Вектор ошибки, соответствующий введенному кодовому вектору')
pp(e_)
print('Кратность')
pp(qe_)
a_est = lc.decode(s_est, G)
a__ = lc.decode(s_, G)
print('Информационный вектор')
pp(a__)
pp(s_)
print('Введенный информационный вектор')
pp(a_)
pp(s_)
assert (a__ == a_)
pp('All Ok')
def checker(group, student, task_code):
fname = f'{student}_{task_code}_{group}.xlsx'
print(f'\n')
print(f'*********************')
print(f'Чтение файла {fname}')
try:
wb = load_workbook(fname)
except FileNotFoundError:
print(f'Файл {fname} не найден')
return
ws = wb['Main']
G = []
parameters = []
for row in ws.iter_rows(min_row=1,
max_col=max_n,
max_row=16 + max_k,
values_only=True):
row = list(filter(None.__ne__, row)) # Убирает ненужные None
g_Ok = is_bits_vector(row)
n = len(row)
if g_Ok and n >= min_n and n <= max_n:
G.append(row) # Читаем порождающую матрицу G кода
if n == 1 and isinstance(row[0], int):
parameters.append(row[0])
print('Порождающая матрица кода')
pp(G)
k, n, ok = lc.check_matrix(G)
r = n - k
assert ((len(parameters) == 6) and ok)
n_, k_, r_, d_, qo_, qi_ = parameters
Wsp = lc.gen_spectrum(G)
d = lc.spectrum_to_code_distance(Wsp)
qo = d - 1
qi = (d - 1) // 2
print('Правильные ответы:')
pp(f'n = {n}')
pp(f'k = {k}')
pp(f'r = {r}')
pp(f'd = {d}')
pp(f'qo = {qo}')
pp(f'qi = {qi}')
print('Введенные ответы:')
pp(f'n = {n_}')
pp(f'k = {k_}')
pp(f'r = {r_}')
pp(f'd = {d_}')
pp(f'qo = {qo_}')
pp(f'qi = {qi_}')
assert (n_ == n)
assert (k_ == k)
assert (r_ == r)
assert (d_ == d)
assert (qo_ == qo)
assert (qi_ == qi)
wsSp = wb['CodeSpectrum']
tmp_ = []
for row in wsSp.iter_rows(min_row=1,
max_col=max_n + 1,
max_row=5,
values_only=True):
row = list(filter(None.__ne__, row))
g_Ok = is_int_vector(row)
n = len(row)
if g_Ok and n <= max_n + 1:
tmp_.append(row)
assert (len(tmp_) == 2)
spC_ = dict((k, v) for k, v in zip(tmp_[0], tmp_[1]) if v > 0)
print('Правильный спектр кода')
pp(Wsp)
print('Введенный спектр кода')
pp(spC_)
assert (spC_ == Wsp)
pp('All Ok')
def generator(group, student, task_code):
# Генерация случайных (n, k) так, что k < n
while True:
n = lc.randint(min_n, max_n)
k = lc.randint(min_k, max_k)
if k < n and (n - k) >= min_r:
break
# print(f'Введите нижнюю границу кодового расстояния (n, k)-кода ({n}, {k})')
d_recomend = lc.get_recomend_code_distance(n, k)
# print(f'Рекомендуется не более {d_recomend}')
#try:
# d_low_bound = int(input())
#except:
# d_low_bound = 2
print(f'Подождите идет подбор порождающей матрицы G с кодовым \
расстоянием не ниже {d_recomend}...')
G, _ = lc.gen_matrix(n, k, d_recomend)
Gsh, *_ = lc.shuffle_matrix(G, n, True, [])
print('Порождающая матрица G в систематической форме')
pp(G)
print('Матрица G после тасовки')
pp(Gsh)
Wsp = lc.gen_spectrum(G)
print('Спектр кода Wsp по исходной матрице G (систематической)')
pp(Wsp)
Wspsh = lc.gen_spectrum(Gsh)
print('Спектр кода Wsp по тасованной матрице G')
pp(Wspsh)
wb = Workbook()
ws = wb.active
ws.title = 'Main'
hf = Font(name='Calibri', bold=True)
ws['A1'].font = hf
ws['A1'] = 'Порождающая матрица G'
for g_r in Gsh:
ws.append(g_r)
ws.append(['Введите ответы:'])
ws.cell(row=ws.max_row, column=1).font = hf
ws.append(['Длина кода n:'])
ws.append([0])
ws.append(['Число информационных символов k:'])
ws.append([0])
ws.append(['Число проверочных символов r:'])
ws.append([0])
ws.append(['Кодовое расстояние кода dк:'])
ws.append([0])
ws.append(['Кратность гарантированного обнаружения qо:'])
ws.append([0])
ws.append(['Кратность гарантированного исправления qи:'])
ws.append([0])
spectr_name = 'CodeSpectrum'
ws.append([f'Не забудьте заполнить лист {spectr_name}!'])
ws.cell(row=ws.max_row, column=1).font = hf
wsWC = wb.create_sheet(spectr_name)
wsWC['A1'].font = hf
wsWC['A1'] = 'Введите спектр Wsp(C) кода (в отсортированном порядке)'
wsWC.append(['Веса w:'])
wsWC.append([i for i in range(n + 1)])
wsWC.append(['Количество весов Nw:'])
wsWC.append([0] * (n + 1))
wb.save(f'{student}_{task_code}_{group}.xlsx')
print(f'Ok = {ok}', flush=True)
assert (ok)
print(f'Elapsed {t1 - t0} s', flush=True)
print(f'Find code distance by check matrix...', flush=True)
t0 = time.perf_counter()
d = lc.get_code_distance(Hsh, False)
t1 = time.perf_counter()
print(f'Elapsed {t1 - t0} s', flush=True)
print(f'Find code distance by check matrix (method 2)...', flush=True)
t0 = time.perf_counter()
d2 = lc.get_code_distance_2(Hsh, False)
t1 = time.perf_counter()
print(f'Elapsed {t1 - t0} s', flush=True)
print(f'Generation code and calc spectrum and distance...', flush=True)
t0 = time.perf_counter()
Wsp = lc.gen_spectrum(Gsh)
dist = lc.spectrum_to_code_distance(Wsp)
t1 = time.perf_counter()
print(f'Elapsed {t1 - t0} s', flush=True)
print(f'd_max = {d_max}, d_low = {d_low}, d = {d}, d2 = {d2}, \
d_dist = {dist}',
flush=True)
assert (d == dist)
assert (d2 == dist)
assert (d >= d_low)
assert (Wsp[0] == 1)
assert (sum(Wsp.values()) == 2**k)
a = lc.get_rand_bits(k)
s = lc.mult_v(a, Gsh)
print(f'Transmitted code vector s = {s}')
qi = (d - 1) // 2 # Целевая кратность ошибки - кратность исправления