def decode(self, W, method='euclid'): num_of_message = W.shape[0] answ = numpy.empty(W.shape, dtype=int) double_t = 2 * self.t for i in range(num_of_message): if method == 'euclid': syndrome_arr = gf.polyval(W[i], self.R, self.pm) if not any(syndrome_arr): answ[i] = W[i] continue syndrome_arr = numpy.hstack( (syndrome_arr, numpy.array([1], dtype=int))) z_in_pow_poly = numpy.zeros(double_t + 2, dtype=int) z_in_pow_poly[0] = 1 zero_counter = 0 for x in syndrome_arr: if x == 0: zero_counter += 1 else: break Lambda = gf.euclid(z_in_pow_poly, syndrome_arr[zero_counter:], self.pm, self.t)[2] Lambda_pow = Lambda.shape[0] - 1 answ[i], num_of_root = self.correction(Lambda, W[i]) if Lambda_pow != num_of_root: answ[i] = numpy.nan #answ[i] = 2 Программы со сбором статистики, построением графиков, ожидают, #что при отказах будет возвращаться строка двоек из-за проблем со сравнением numpy.nan находящегося в целочисленном массиве continue else: syndrome_arr = gf.polyval(W[i], self.R_for_pgz, self.pm) if not any(syndrome_arr): answ[i] = W[i] continue arr = numpy.empty((self.t, self.t), dtype=int) for k in range(self.t): arr[k] = syndrome_arr[k:k + self.t] b_arr = numpy.array(syndrome_arr[self.t:]) j = 0 while j != self.t: Lambda = gf.linsolve(arr[:self.t - j, :self.t - j], b_arr, self.pm) if not numpy.array_equal(Lambda, Lambda): j += 1 b_arr = syndrome_arr[self.t - j:2 * (self.t - j)] else: break if j == self.t: answ[i] = numpy.nan #answ[i] = 2 continue Lambda = numpy.hstack((Lambda, numpy.array([1]))) answ[i] = self.correction(Lambda, W[i])[0] if any(gf.polyval(answ[i], self.R_for_pgz, self.pm)): answ[i] = numpy.nan #answ[i] = 2 return answ
def decode(self, W, method='euclid'): message_number, n = W.shape # res - результат res = np.zeros(W.shape).astype('int') # PGZ for i in range(message_number): # s - синдром # для принятоо слова W вычислим синдром s = gf.polyval(W[i, :], self.R, self.pm) # если все s = 0, то возвращаем W в качестве ответа if np.all(s == 0): res[i] = W[i].copy() continue # вычислим коэффициенты полинома локаторов ошибок путем решения СЛАУ if method == 'pgz': for j in range(self.t, 0, -1): # составим матрицу A для СЛАУ A = np.zeros((j, j)).astype('int') for k in range(j): A[k, :] = s[k:k + j] b = s[j:2 * j] # решаем СЛАУ Lambda = gf.linsolve(A, b, self.pm) if not np.any(np.isnan(Lambda)): break if np.any(np.isnan(Lambda)): res[i] = np.nan continue Lambda = np.append(Lambda, np.array([1])) elif method == 'euclid': s = np.append(s[::-1], np.array([1])) # z^(2t + 1) z = np.zeros(((self.R.size + 1) + 1), dtype=np.int) z[0] = 1 # алгоритм евклида # z^(2t + 1) * A(z) + S(z)L(z) = r(z) # находим L(z) Lambda = gf.euclid(z, s, self.pm, max_deg=self.t)[2] # получаем позиции ошибок roots = gf.polyval(Lambda, self.pm[:, 1], self.pm) pos_error = np.nonzero(roots.reshape(-1) == 0)[0] # инвертируем биты в позициях ошибок tmp = W[i].copy() tmp[pos_error] = 1 - tmp[pos_error].astype(np.int) res[i] = tmp s = gf.polyval(res[i].astype(int), self.R, self.pm) if not np.all(s == 0): res[i, :] = np.ones(self.n) * np.nan continue return res
def decode(self, W, method='euclid'): assert method == 'euclid' or method == 'pgz' t = self.R.shape[0] // 2 n = W.shape[1] is_nan = False assert n == self.pm.shape[0] res = np.zeros_like(W, dtype=object) for i in range(W.shape[0]): w = W[i] s = gf.polyval(w, self.R, self.pm) if (s == 0).all(): res[i] = w continue if method == 'euclid': s = s[::-1] z = np.zeros(2 * t + 2, dtype=np.int64) z[0] = 1 s = np.concatenate((s, np.array([1]))) r, a, lam = gf.euclid(z, s, self.pm, max_deg=t) else: lam = np.nan for errors in range(t, 0, -1): A = [[s[k] for k in range(j, j + errors)] for j in range(errors)] A = np.array(A) b = [s[k] for k in range(errors, errors * 2)] b = np.array(b) lam = gf.linsolve(A, b, self.pm) if lam is not np.nan: break if lam is np.nan: res[i] = np.nan is_nan = True continue lam = np.concatenate((lam, np.array([1]))) values = gf.polyval(lam, self.pm[:, 1], self.pm) num_roots = 0 #res[i] = w for j in range(values.shape[0]): if values[j] == 0: root = self.pm[j, 1] alpha = gf.divide(1, root, self.pm) index = self.pm[alpha - 1, 0] w[n - index - 1] = 1 - w[n - index - 1] num_roots += 1 if num_roots != lam.shape[0] - 1: res[i] = np.nan is_nan = True continue res[i] = w if not is_nan: res = res.astype(np.int64) return res
def decode(self, W, method='euclid'): V = W.astype(object) for i in range(len(V)): s = gf.polyval(V[i], self.R, self.pm) for j in s: if j != 0: break else: continue if method == 'pgz': e = s.size//2 while e > 0: S = np.empty((e,e),int) for j in range(e): S[j] = s[j:j+e] x = gf.linsolve(S,s[e:2*e],self.pm) if not np.any(np.isnan(x)): break e -= 1 else: V[i,:] = np.nan continue x = np.append(x, [1]) if method == 'euclid': S = np.append(s[::-1], [1]) x = np.zeros(s.size + 2,int) x[0] = 1 x = gf.euclid(x, S, self.pm, max_deg=s.size//2)[2] e = x.size - 1 x = gf.polyval(x, self.pm[:,1], self.pm) x = self.pm[np.flatnonzero(x==0), 1] if method == 'euclid' and x.size != e: V[i,:] = np.nan continue x = self.pm[x-1,0] - 1 V[i,x] = V[i,x]^1 if method == 'pgz': s = gf.polyval(V[i], self.R, self.pm) for j in s: if j != 0: V[i,:] = np.nan break return V
def decode(self, W, method='euclid'): d = self.g.shape[0] - 1 ans = np.zeros((W.shape[0], self.k)) for j in range(W.shape[0]): w = W[j] s = np.array(gf.polyval(w, self.pm.T[1][:2*self.t], self.pm)) b = 0 for i in s: if(i != 0): b = 1 if (b == 0): ans[j] = w[:self.k] else: n = np.array([0]) r = w.copy() self.time = 0 b = 0 if (method == 'PGZ'): start_time = time.time() n = np.array(self.PGZ(s)) self.time += time.time() - start_time if (method == 'euclid'): start_time = time.time() n = self.EVCL(s) self.time += time.time() - start_time if (n is np.nan): b = 1 ans[j] = np.nan continue else: n = n.astype(int) a = gf.polyval(n, self.pm.T[1], self.pm) an = [] for i in range(a.shape[0]): if a[i] == 0: an = an + [i] rr = np.array(an) for i in rr: r[i] = (r[i] + 1) % 2 s = np.array(gf.polyval(r, self.pm.T[1][:2*self.t], self.pm)) for i in s: if(i != 0): b = 1 if (b == 1): ans[j] = np.nan else: ans[j] = r[:self.k] return ans
def test_polyval(): pm = gf.gen_pow_matrix(37) p = np.array([11, 29, 26, 31, 3]) x = np.array([19, 25, 31, 3, 14, 29]) right_answer = np.array([ 3, 12, 19, 26, 22, 1]) assert_equal(right_answer, gf.polyval(p, x, pm))
def decode_msg(w): syndromes = gf.polyval(_lstrip0(w), self.R, pm=self.pm) if (syndromes == 0).all(): return _np.copy(w) errloc_poly = decoder(w, syndromes) if errloc_poly is _np.nan: return _np.full(self.n, _np.nan) vals = gf.polyval(errloc_poly, pm_powsfrom0, pm=self.pm) roots_degs = _np.where(vals == 0)[0] v = _np.copy(w) v[roots_degs - 1] ^= 1 _, r = gf.binpolydiv(_lstrip0(v), self.g) if not gf.isnull(r): return _np.full(self.n, _np.nan) v_syndromes = gf.polyval(_lstrip0(v), self.R, pm=self.pm) if (v_syndromes != 0).any(): return _np.full(self.n, _np.nan) return v
def decode(self, w, method='euclid'): f = open(method + '.txt', 'a') u = np.zeros((w.shape[0], w.shape[1]), int) for i in range(w.shape[0]): s = gf.polyval(w[i], self.R, self.pm) if np.count_nonzero(s) == 0: u[i] = w[i] continue if method == 'pgz': t = time.clock() A, b = build_m(s, self.t) L = gf.linsolve(A, b, self.pm) step = self.t - 1 while type(L) == type(np.nan) and step > 0: A, b = build_m(s, step) L = gf.linsolve(A, b, self.pm) step -= 1 if type(L) == type(np.nan): u[i] = -1 continue L = np.concatenate((L, [1])) t = time.clock() - t if method == 'euclid': t = time.clock() s = np.concatenate((s[::-1], [1])) z = np.zeros(2 * self.t + 2, int) z[0] = 1 L = gf.euclid(z, s, self.pm, self.t)[2] t = time.clock() - t f.write(str(t) + '\n') val = gf.polyval(L, self.pm[:, 1].reshape((self.pm.shape[0])), self.pm) pos = [] for a in range(val.size): if val[a] == 0: pos.append(a) if len(pos) != L.size - 1: u[i] = -1 continue u[i] = w[i] for j in pos: u[i, j] = (u[i, j] + 1) % 2 f.close() return u
def decoding(W, R, pm, method='euclid'): n_mes = W.shape[0] n = W.shape[1] V = np.zeros((n_mes, n)) t = int(R.size / 2) for mes_idx in range(n_mes): # Step 1. Computing syndrome polynomials: s = gf.polyval(W[mes_idx, :], R, pm) if np.count_nonzero(s) == 0: V[mes_idx, :] = W[mes_idx, :] continue # Step 2. Computing Lambda(z) coefficients: # PGZ decoder: if method == 'pgz': for nu in range(t, 0, -1): A = hankel(s[:nu], s[(nu - 1):(2 * nu - 1)]) b = s[nu:(2 * nu)] x = gf.linsolve(A, b, pm) if np.all(np.isnan(x) == False): break if np.any(np.isnan(x) == True): W[mes_idx, :] = np.nan continue Lambda = np.append(x, [1]) # Euclid decoder: elif method == 'euclid': S = np.append(s[::-1], [1]) z_pow_d = np.zeros((2 * t + 2), dtype=int) z_pow_d[0] = 1 Lambda = gf.euclid(z_pow_d, S, pm, max_deg=t)[2] else: raise ValueError("Unknown method name") # Step 3 and 4. Finding all roots of Lambda(z) and # Computing error positions: error_positions = np.where(gf.polyval(Lambda, pm[:, 1], pm) == 0)[0] # Step 5. Computing decoded message: v = W[mes_idx, :].copy() v[error_positions] = np.abs(v[error_positions] - 1) # Step 6. Checking decoded message: if np.count_nonzero(gf.polyval(v, R, pm)) == 0: V[mes_idx, :] = v.copy() else: V[mes_idx, :] = np.nan return V
def decode(self, W, method='euclid'): result = np.empty(W.shape) for index, w in enumerate(W): result[index] = w s = gf.polyval(w, self.R, self.pm) if np.all(s == 0): continue if method == 'euclid': s = np.hstack((s[::-1], np.array([1], int))) i = 0 while s[i] == 0: i += 1 loc = gf.euclid( np.hstack((np.array([1], int), np.zeros(self.R.size + 1, int))), s[i:], self.pm, self.R.size >> 1)[2] else: t = self.R.size >> 1 A = np.empty((t, t), int) for i in range(t): A[i] = s[i:i + t] for v in range(t, 0, -1): loc = gf.linsolve(A[:v, :v], s[v:2 * v], self.pm) if np.array_equal(loc, loc): loc = np.hstack((loc, np.array([1], int))) break if not np.array_equal(loc, loc): result[index].fill(np.nan) continue roots_count = 0 for i, val in enumerate(self.pm[:, 1]): if gf.polyval(loc, val.reshape(1), self.pm)[0] == 0: roots_count += 1 result[index][i] = int(result[index][i]) ^ 1 if method == 'euclid' and roots_count != loc.size - 1: result[index].fill(np.nan) elif method == 'pgz': s = gf.polyval(result[index].astype(int), self.R, self.pm) if np.any(s != 0): result[index].fill(np.nan) return result
def correction(self, Lambda, Q): lambda_val_in_alpha = gf.polyval(Lambda, self.all_roots, self.pm) num_of_lambda_root = 0 root_position = [] for j in range(self.n): if lambda_val_in_alpha[j] == 0: num_of_lambda_root += 1 root_position.append(j) e_row = numpy.zeros(self.n, dtype=int) for k in root_position: e_row[k] = 1 return Q ^ e_row, num_of_lambda_root
def _decode(self, w, method): t = self.R.shape[0] // 2 syndromes = gf.polyval(w, self.R, self.pm) if np.sum(syndromes != 0) == 0: return w if method == 'pgz': lambda_ = np.nan for nu in range(t, 0, -1): a = np.array([[syndromes[j] for j in range(i, nu + i)] for i in range(nu)], dtype=np.int) b = np.array([syndromes[i] for i in range(nu, 2 * nu)], dtype=np.int) lambda_ = gf.linsolve(a, b, self.pm) if lambda_ is not np.nan: break if lambda_ is np.nan: return np.full(self.n, np.nan, dtype=np.int) lambda_ = np.concatenate([lambda_, [1]]) elif method == 'euclid': z = np.zeros([2 * t + 2], dtype=np.int) z[0] = 1 syndromic_polynom = np.concatenate([syndromes[::-1], [1]]) _, _, lambda_ = gf.euclid(z, syndromic_polynom, self.pm, max_deg=t) else: raise ValueError n_roots = 0 locators_values = gf.polyval(lambda_, np.arange(1, self.n + 1), self.pm) for idx in range(1, self.n + 1): if not locators_values[idx - 1]: position = self.n - self.pm[gf.divide(1, idx, self.pm) - 1, 0] - 1 w[position] = 1 - w[position] n_roots += 1 if n_roots != lambda_.shape[0] - 1: return np.full(self.n, np.nan, dtype=np.int) return w
def decode(self, W, method='euclid'): alpha = np.array([2], np.int) curr_deg = alpha alpha_list_t = [alpha[0]] for i in range(2 * self.t - 1): curr_deg = gf.prod(curr_deg, alpha, self.pm) alpha_list_t.append(curr_deg[0]) alpha_list_n = alpha_list_t.copy() for i in range(self.n - 2 * self.t): curr_deg = gf.prod(curr_deg, alpha, self.pm) alpha_list_n.append(curr_deg[0]) alpha_list_t = np.array(alpha_list_t) alpha_list_n = np.array(alpha_list_n) result = np.zeros(W.shape, np.int) if method == 'pgz': for row in range(W.shape[0]): deg_list = gf.polyval(W[row], alpha_list_t, self.pm) if np.all(deg_list == 0): result[row] = W[row] else: curr_dim = self.t while (curr_dim > 0): A = np.zeros((curr_dim, curr_dim), np.int) for i in range(curr_dim): A[i] = deg_list[i:curr_dim + i] b = deg_list[curr_dim:2 * curr_dim] value = gf.linsolve(A, b, self.pm) if value is not np.nan: value = np.concatenate((value, np.ones(1, np.int))) break curr_dim -= 1 if curr_dim == 0: result[row] = np.nan else: roots = gf.polyval(value, alpha_list_n, self.pm) roots = np.nonzero(np.logical_not(roots)) err_pos = (roots[0]) % self.n result[row] = W[row] result[row, err_pos] = np.logical_not( result[row, err_pos]).astype(np.int) if np.any( gf.polyval(result[row], alpha_list_t, self.pm) != 0): result[row, :] = np.nan elif method == 'euclid': alpha_list_t = alpha_list_t[::-1] for row in range(W.shape[0]): S = gf.polyval(W[row], alpha_list_t, self.pm) S = np.concatenate((S, np.ones(1, np.int))) z = np.array([1] + [0 for x in range(2 * self.t + 1)], np.int) r, A, Lambda = gf.euclid(z, S, self.pm, self.t) roots = gf.polyval(Lambda, alpha_list_n, self.pm) roots = np.nonzero(np.logical_not(roots)) err_pos = (roots[0]) % self.n result[row] = W[row] result[row, err_pos] = np.logical_not( result[row, err_pos]).astype(np.int) if np.any(gf.polyval(result[row], alpha_list_t, self.pm) != 0): result[row, :] = np.nan return result
def test(n, t, errors): result_euc = list() #result_pgz = list() code = bch.BCH(n, t) polynom = np.zeros(n + 1, int) polynom[0] = 1 polynom[-1] = 1 if gf.polydiv(polynom, code.g, code.pm)[1] != []: print('Error!!!') U = np.random.randint(0, 2, (100, n - code.g.size + 1)) V = code.encode(U) for v in V: if gf.polydiv(v, code.g, code.pm)[1] != []: print('Error!!!') if gf.polyval(v, code.R, code.pm).any(): print('Error!!!') for k in code.g: if k != 0 and k != 1: print('Error!!!') for err in errors: correct = 0 wrong = 0 detected = 0 W = noise(V, err) Vx = code.decode(W, 'euclid') for i in range(V.shape[0]): if np.array_equal(V[i], Vx[i]): correct += 1 elif not np.array_equal(Vx[i], Vx[i]): detected += 1 else: wrong += 1 print(correct, detected, wrong) result_euc.append([correct / 100, detected / 100, wrong / 100]) '''correct = 0 wrong = 0 detected = 0 Vx = code.decode(W, 'pgz') for i in range(V.shape[0]): if np.array_equal(V[i], Vx[i]): correct += 1 elif not np.array_equal(Vx[i], Vx[i]): detected += 1 else: wrong += 1 print(correct, detected, wrong) result_pgz.append((correct / 100, detected / 100, wrong / 100))''' return result_euc #, result_pgz
def do_correctness_test(self, q, t, get_msg=None): pbar = tqdm(total=8) n = 2 ** q - 1 code = BCH(n, t) pbar.update(1) self.assertTrue(np.logical_or((code.g == [0]), (code.g == [1])).all()) self.assertRaises(BaseException, lambda it: code.decode([np.zeros(n + 1).astype(int)])) pbar.update(1) x = np.zeros(n + 1).astype(int) x[0] = 1 x[-1] = 1 assert_array_equal(gf.polydiv(x, code.g, code.pm)[1], [0]) pbar.update(1) m = code.g.shape[0] - 1 #gf.polydeg(code.g) k = n - m self.assertRaises(BaseException, lambda it: code.encode([np.zeros(k + 1).astype(int)])) if get_msg is None: msg = [random.randint(0, 1) for _ in range(0, k)] else: msg = get_msg(k) coded = code.encode(np.array([msg]))[0] assert_array_equal(coded[0:k], msg) pbar.update(1) self.assertTrue((gf.polyval(coded, code.R, code.pm) == [0]).all()) pbar.update(1) assert_array_equal(gf.polydiv(coded, code.g, code.pm)[1], [0]) pbar.update(1) assert_array_equal(code.decode(np.array([coded]))[0], coded) pbar.update(1) if t >= 1: broken = np.array(coded) goig_to_make_count_mistakes = random.randint(0, t) mistakes = 0 i = 0 while mistakes < goig_to_make_count_mistakes and i < len(broken): if random.randint(0, 1) == 1: broken[i] = 1 - broken[i] mistakes += 1 i += 1 assert_array_equal(code.decode(np.array([broken]), method='pgz')[0], coded) assert_array_equal(code.decode(np.array([broken]), method='euclid')[0], coded) assert_array_equal(code.decode(np.array([broken]))[0], coded) pbar.update(1) pbar.close()
def dist(self, check=False): k = len(self.pm) - self.g.size + 1 d = len(self.pm) u = np.arange(k - 1, -1, -1).reshape(1,-1) for i in range(2**k): v = self.encode((i >> u) & 1).reshape(-1) if check: r = gf.polydiv(v, self.g, self.pm)[1] if r.size != 1 or r[0] != 0: return False s = gf.polyval(v, self.R, self.pm) for j in s: if j != 0: return False b = np.sum(v) if b < d and b != 0: d = b if check: return d >= self.R.size + 1 else: return d
def decode(self, W, method='euclid'): sindrom = np.zeros((W.shape[0], 2*self.t)).astype('int') V_hat = np.zeros((W.shape)).astype('int') error = [] for i in range(W.shape[0]): sindrom[i, :] = gf.polyval(W[i, :], self.R, self.pm) if np.all(sindrom[i, :] == 0): V_hat[i, :] = W[i, :] else: error.append(i) for i in error: if method == 'euclid': # sindrom polynom sindrom_poly = np.zeros(2*self.t + 1).astype('int') s = sindrom[i, :] s = s[::-1] sindrom_poly[: -1] = s sindrom_poly[-1] = 1 # z^(2t + 1) z = np.zeros(2*self.t + 2).astype('int') z[0] = 1 #euclid algorithm r, A, loc_poly_coef = gf.euclid(z, sindrom_poly, self.pm, max_deg=self.t) elif method == 'pgz': s = sindrom[i, :] for errors_n in range(self.t, 0, -1): # matrix for linear solve S = np.zeros((errors_n, errors_n)).astype('int') for j in range(errors_n): S[j, :] = s[j: j + errors_n] b = s[errors_n: 2 * errors_n] lambda_ = gf.linsolve(S, b,self.pm) if np.all(np.isnan(lambda_)): continue else: break # decode error if (errors_n == 1) and np.all(np.isnan(lambda_)): V_hat[i, :] = np.ones(self.n) * np.nan continue # coef of locator polynoms loc_poly_coef = np.zeros(lambda_.shape[0] + 1).astype('int') loc_poly_coef[-1] = 1 loc_poly_coef[: -1] = lambda_ # find root locator_val = gf.polyval(loc_poly_coef, self.pm[:, 1], self.pm) roots = self.pm[np.where(locator_val == 0)[0], 1] pos_error = (-self.pm[roots - 1, 0]) % self.pm.shape[0] pos_error = self.n - pos_error - 1 #error polynom error_poly = np.zeros(self.n).astype('int') error_poly[pos_error] = 1 #decode v_hat = W[i, :] ^ error_poly s_v_hat = gf.polyval(v_hat, self.R, self.pm) if not np.all(s_v_hat == 0): V_hat[i, :] = np.ones(self.n) * np.nan continue if (roots.shape[0] != loc_poly_coef.shape[0] - 1): V_hat[i, :] = np.ones(self.n) * np.nan continue V_hat[i, :] = v_hat return V_hat
def decode(self, W, method="euclid"): """Декодирование БЧХ""" fi = [] for w in W: synd = polyval(w, self.R, self.pm) t = 0 for i in synd: if i != 0: t = -1 break if t == 0: fi.append(w) continue if method == "pgz": v = self.t while v > 0: synd_m = np.empty([v, v], dtype=int) for i in range(synd_m.shape[0]): for j in range(synd_m.shape[1]): synd_m[i][j] = synd[i + j] synd_b = np.empty([v], dtype=int) for i in range(synd_b.shape[0]): synd_b[i] = synd[v + i] L = linsolve(synd_m, synd_b, self.pm) if np.isnan(L[0]): v -= 1 continue L = np.hstack([L, np.asarray(1)]) L_roots = set() for i in range(self.pm.shape[0]): x = polyval(L, np.asarray([self.pm[i][1]]), self.pm) if (x[0] == 0): L_roots.add(self.pm[i][1]) for i in L_roots: j = self.pm[i - 1][0] w[j - 1] ^= 1 synd = polyval(w, self.R, self.pm) t = 0 for i in synd: if i != 0: t = -1 break if t == 0: fi.append(w) break else: fi.append(np.nan) break if v == 0: fi.append(np.nan) else: synd = np.concatenate((np.flip(synd), np.asarray([1]))) x = np.concatenate((np.asarray([1]), np.zeros(2 * self.t + 1, dtype=int))) a, b, L = euclid(x, synd, self.pm, self.t) L_roots = set() for i in range(self.pm.shape[0]): x = polyval(L, np.asarray([self.pm[i][1]]), self.pm) if x[0] == 0: L_roots.add(self.pm[i][1]) power = L.size - 1 i = 0 while L[i] == 0: power -= 1 i += 1 if len(L_roots) != power: # количество корней не совпадает fi.append(np.nan) continue for i in L_roots: j = self.pm[i - 1][0] w[j - 1] ^= 1 synd = polyval(w, self.R, self.pm) t = 0 for i in synd: if i != 0: t = -1 break if t == 0: fi.append(w) continue else: fi.append(np.nan) continue return np.asarray(fi)