def make_negative(self) -> 'Polynomial': """ Returns a Negative version of this instance """ result = list([0] * self.length) for i in range(self.length): result[i] = Modulus.negate(self.coefficients[i]) return Polynomial(0, 0, result)
def test_codewords(codewords: list, error_correction_length: int) -> tuple: """ Decode the received codewords """ poly_codewords = Polynomial(0, 0, codewords) # create syndrom coefficients array syndrome = list([0] * error_correction_length) # assume new errors error = False # test for errors # if the syndrom array is all zeros, there is no error for i in range(error_correction_length, 0, -1): # TODO: This may have been translated incorrectly! Confirm it's not broken. # Original Code: if((Syndrome[ErrorCorrectionLength - Index] = PolyCodewords.EvaluateAt(Modulus.ExpTable[Index])) != 0) Error = true; mod_exp_table_result = Modulus.exp_table[i] evaluate_result = poly_codewords.evaluate_at(mod_exp_table_result) syndrome_index = error_correction_length - i syndrome[syndrome_index] = evaluate_result if (syndrome[syndrome_index] != 0): error = True if (not error): return (0, codewords) # convert syndrom array to polynomial poly_syndrome = Polynomial(0, 0, syndrome) # Greatest Common Divisor (return -1 if error cannot be corrected) result = euclidean_algorithm(error_correction_length, poly_syndrome) if (not result[0]): return (-1, codewords) error_locator = result[1] error_evaluator = result[2] error_locations = find_error_locations(error_locator) if (error_locations is None): return (-1, codewords) formal_derivative = find_formal_derivatives(error_locator) errors = len(error_locations) # This is directly applying Forney's Formula for i in range(errors): error_location = error_locations[i] error_position = len(codewords) - 1 - Modulus.log_table[Modulus.invert( error_location)] if (error_position < 0): return (-1, codewords) error_magnitude = Modulus.divide( Modulus.negate(error_evaluator.evaluate_at(error_location)), formal_derivative.evaluate_at(error_location)) corrected_codeword = Modulus.subtract(codewords[error_position], error_magnitude) codewords[error_position] = corrected_codeword error_locations[i] = error_position return (errors, codewords)