mirror of
https://github.com/AlexandreRouma/SDRPlusPlus.git
synced 2025-06-30 06:17:49 +02:00
Bugfix + added M17 decoder to the linux CI
This commit is contained in:
AlexandreRouma
2
core/libcorrect/src/reed-solomon/CMakeLists.txt
Normal file
2
core/libcorrect/src/reed-solomon/CMakeLists.txt
Normal file
@ -0,0 +1,2 @@
|
||||
set(SRCFILES polynomial.c reed-solomon.c encode.c decode.c)
|
||||
add_library(correct-reed-solomon OBJECT ${SRCFILES})
|
||||
508
core/libcorrect/src/reed-solomon/decode.c
Normal file
508
core/libcorrect/src/reed-solomon/decode.c
Normal file
@ -0,0 +1,508 @@
|
||||
#include "correct/reed-solomon/encode.h"
|
||||
|
||||
// calculate all syndromes of the received polynomial at the roots of the generator
|
||||
// because we're evaluating at the roots of the generator, and because the transmitted
|
||||
// polynomial was made to be a product of the generator, we know that the transmitted
|
||||
// polynomial is 0 at these roots
|
||||
// any nonzero syndromes we find here are the values of the error polynomial evaluated
|
||||
// at these roots, so these values give us a window into the error polynomial. if
|
||||
// these syndromes are all zero, then we can conclude the error polynomial is also
|
||||
// zero. if they're nonzero, then we know our message received an error in transit.
|
||||
// returns true if syndromes are all zero
|
||||
static bool reed_solomon_find_syndromes(field_t field, polynomial_t msgpoly, field_logarithm_t **generator_root_exp,
|
||||
field_element_t *syndromes, size_t min_distance) {
|
||||
bool all_zero = true;
|
||||
memset(syndromes, 0, min_distance * sizeof(field_element_t));
|
||||
for (unsigned int i = 0; i < min_distance; i++) {
|
||||
// profiling reveals that this function takes about 50% of the cpu time of
|
||||
// decoding. so, in order to speed it up a little, we precompute and save
|
||||
// the successive powers of the roots of the generator, which are
|
||||
// located in generator_root_exp
|
||||
field_element_t eval = polynomial_eval_lut(field, msgpoly, generator_root_exp[i]);
|
||||
if (eval) {
|
||||
all_zero = false;
|
||||
}
|
||||
syndromes[i] = eval;
|
||||
}
|
||||
return all_zero;
|
||||
}
|
||||
|
||||
// Berlekamp-Massey algorithm to find LFSR that describes syndromes
|
||||
// returns number of errors and writes the error locator polynomial to rs->error_locator
|
||||
static unsigned int reed_solomon_find_error_locator(correct_reed_solomon *rs, size_t num_erasures) {
|
||||
unsigned int numerrors = 0;
|
||||
|
||||
memset(rs->error_locator.coeff, 0, (rs->min_distance + 1) * sizeof(field_element_t));
|
||||
|
||||
// initialize to f(x) = 1
|
||||
rs->error_locator.coeff[0] = 1;
|
||||
rs->error_locator.order = 0;
|
||||
|
||||
memcpy(rs->last_error_locator.coeff, rs->error_locator.coeff, (rs->min_distance + 1) * sizeof(field_element_t));
|
||||
rs->last_error_locator.order = rs->error_locator.order;
|
||||
|
||||
field_element_t discrepancy;
|
||||
field_element_t last_discrepancy = 1;
|
||||
unsigned int delay_length = 1;
|
||||
|
||||
for (unsigned int i = rs->error_locator.order; i < rs->min_distance - num_erasures; i++) {
|
||||
discrepancy = rs->syndromes[i];
|
||||
for (unsigned int j = 1; j <= numerrors; j++) {
|
||||
discrepancy = field_add(rs->field, discrepancy,
|
||||
field_mul(rs->field, rs->error_locator.coeff[j], rs->syndromes[i - j]));
|
||||
}
|
||||
|
||||
if (!discrepancy) {
|
||||
// our existing LFSR describes the new syndrome as well
|
||||
// leave it as-is but update the number of delay elements
|
||||
// so that if a discrepancy occurs later we can eliminate it
|
||||
delay_length++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (2 * numerrors <= i) {
|
||||
// there's a discrepancy, but we still have room for more taps
|
||||
// lengthen LFSR by one tap and set weight to eliminate discrepancy
|
||||
|
||||
// shift the last locator by the delay length, multiply by discrepancy,
|
||||
// and divide by the last discrepancy
|
||||
// we move down because we're shifting up, and this prevents overwriting
|
||||
for (int j = rs->last_error_locator.order; j >= 0; j--) {
|
||||
// the bounds here will be ok since we have a headroom of numerrors
|
||||
rs->last_error_locator.coeff[j + delay_length] = field_div(
|
||||
rs->field, field_mul(rs->field, rs->last_error_locator.coeff[j], discrepancy), last_discrepancy);
|
||||
}
|
||||
for (int j = delay_length - 1; j >= 0; j--) {
|
||||
rs->last_error_locator.coeff[j] = 0;
|
||||
}
|
||||
|
||||
// locator = locator - last_locator
|
||||
// we will also update last_locator to be locator before this loop takes place
|
||||
field_element_t temp;
|
||||
for (int j = 0; j <= (rs->last_error_locator.order + delay_length); j++) {
|
||||
temp = rs->error_locator.coeff[j];
|
||||
rs->error_locator.coeff[j] =
|
||||
field_add(rs->field, rs->error_locator.coeff[j], rs->last_error_locator.coeff[j]);
|
||||
rs->last_error_locator.coeff[j] = temp;
|
||||
}
|
||||
unsigned int temp_order = rs->error_locator.order;
|
||||
rs->error_locator.order = rs->last_error_locator.order + delay_length;
|
||||
rs->last_error_locator.order = temp_order;
|
||||
|
||||
// now last_locator is locator before we started,
|
||||
// and locator is (locator - (discrepancy/last_discrepancy) * x^(delay_length) * last_locator)
|
||||
|
||||
numerrors = i + 1 - numerrors;
|
||||
last_discrepancy = discrepancy;
|
||||
delay_length = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
// no more taps
|
||||
// unlike the previous case, we are preserving last locator,
|
||||
// but we'll update locator as before
|
||||
// we're basically flattening the two loops from the previous case because
|
||||
// we no longer need to update last_locator
|
||||
for (int j = rs->last_error_locator.order; j >= 0; j--) {
|
||||
rs->error_locator.coeff[j + delay_length] =
|
||||
field_add(rs->field, rs->error_locator.coeff[j + delay_length],
|
||||
field_div(rs->field, field_mul(rs->field, rs->last_error_locator.coeff[j], discrepancy),
|
||||
last_discrepancy));
|
||||
}
|
||||
rs->error_locator.order = (rs->last_error_locator.order + delay_length > rs->error_locator.order)
|
||||
? rs->last_error_locator.order + delay_length
|
||||
: rs->error_locator.order;
|
||||
delay_length++;
|
||||
}
|
||||
return rs->error_locator.order;
|
||||
}
|
||||
|
||||
// find the roots of the error locator polynomial
|
||||
// Chien search
|
||||
bool reed_solomon_factorize_error_locator(field_t field, unsigned int num_skip, polynomial_t locator_log, field_element_t *roots,
|
||||
field_logarithm_t **element_exp) {
|
||||
// normally it'd be tricky to find all the roots
|
||||
// but, the finite field is awfully finite...
|
||||
// just brute force search across every field element
|
||||
unsigned int root = num_skip;
|
||||
memset(roots + num_skip, 0, (locator_log.order) * sizeof(field_element_t));
|
||||
for (field_operation_t i = 0; i < 256; i++) {
|
||||
// we make two optimizations here to help this search go faster
|
||||
// a) we have precomputed the first successive powers of every single element
|
||||
// in the field. we need at most n powers, where n is the largest possible
|
||||
// degree of the error locator
|
||||
// b) we have precomputed the error locator polynomial in log form, which
|
||||
// helps reduce some lookups that would be done here
|
||||
if (!polynomial_eval_log_lut(field, locator_log, element_exp[i])) {
|
||||
roots[root] = (field_element_t)i;
|
||||
root++;
|
||||
}
|
||||
}
|
||||
// this is where we find out if we are have too many errors to recover from
|
||||
// berlekamp-massey may have built an error locator that has 0 discrepancy
|
||||
// on the syndromes but doesn't have enough roots
|
||||
return root == locator_log.order + num_skip;
|
||||
}
|
||||
|
||||
// use error locator and syndromes to find the error evaluator polynomial
|
||||
void reed_solomon_find_error_evaluator(field_t field, polynomial_t locator, polynomial_t syndromes,
|
||||
polynomial_t error_evaluator) {
|
||||
// the error evaluator, omega(x), is S(x)*Lamba(x) mod x^(2t)
|
||||
// where S(x) is a polynomial constructed from the syndromes
|
||||
// S(1) + S(2)*x + ... + S(2t)*x(2t - 1)
|
||||
// and Lambda(x) is the error locator
|
||||
// the modulo is implicit here -- we have limited the max length of error_evaluator,
|
||||
// which polynomial_mul will interpret to mean that it should not compute
|
||||
// powers larger than that, which is the same as performing mod x^(2t)
|
||||
polynomial_mul(field, locator, syndromes, error_evaluator);
|
||||
}
|
||||
|
||||
// use error locator, error roots and syndromes to find the error values
|
||||
// that is, the elements in the finite field which can be added to the received
|
||||
// polynomial at the locations of the error roots in order to produce the
|
||||
// transmitted polynomial
|
||||
// forney algorithm
|
||||
void reed_solomon_find_error_values(correct_reed_solomon *rs) {
|
||||
// error value e(j) = -(X(j)^(1-c) * omega(X(j)^-1))/(lambda'(X(j)^-1))
|
||||
// where X(j)^-1 is a root of the error locator, omega(X) is the error evaluator,
|
||||
// lambda'(X) is the first formal derivative of the error locator,
|
||||
// and c is the first consecutive root of the generator used in encoding
|
||||
|
||||
// first find omega(X), the error evaluator
|
||||
// we generate S(x), the polynomial constructed from the roots of the syndromes
|
||||
// this is *not* the polynomial constructed by expanding the products of roots
|
||||
// S(x) = S(1) + S(2)*x + ... + S(2t)*x(2t - 1)
|
||||
polynomial_t syndrome_poly;
|
||||
syndrome_poly.order = rs->min_distance - 1;
|
||||
syndrome_poly.coeff = rs->syndromes;
|
||||
memset(rs->error_evaluator.coeff, 0, (rs->error_evaluator.order + 1) * sizeof(field_element_t));
|
||||
reed_solomon_find_error_evaluator(rs->field, rs->error_locator, syndrome_poly, rs->error_evaluator);
|
||||
|
||||
// now find lambda'(X)
|
||||
rs->error_locator_derivative.order = rs->error_locator.order - 1;
|
||||
polynomial_formal_derivative(rs->field, rs->error_locator, rs->error_locator_derivative);
|
||||
|
||||
// calculate each e(j)
|
||||
for (unsigned int i = 0; i < rs->error_locator.order; i++) {
|
||||
if (rs->error_roots[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
rs->error_vals[i] = field_mul(
|
||||
rs->field, field_pow(rs->field, rs->error_roots[i], rs->first_consecutive_root - 1),
|
||||
field_div(
|
||||
rs->field, polynomial_eval_lut(rs->field, rs->error_evaluator, rs->element_exp[rs->error_roots[i]]),
|
||||
polynomial_eval_lut(rs->field, rs->error_locator_derivative, rs->element_exp[rs->error_roots[i]])));
|
||||
}
|
||||
}
|
||||
|
||||
void reed_solomon_find_error_locations(field_t field, field_logarithm_t generator_root_gap,
|
||||
field_element_t *error_roots, field_logarithm_t *error_locations,
|
||||
unsigned int num_errors, unsigned int num_skip) {
|
||||
for (unsigned int i = 0; i < num_errors; i++) {
|
||||
// the error roots are the reciprocals of the error locations, so div 1 by them
|
||||
|
||||
// we do mod 255 here because the log table aliases at index 1
|
||||
// the log of 1 is both 0 and 255 (alpha^255 = alpha^0 = 1)
|
||||
// for most uses it makes sense to have log(1) = 255, but in this case
|
||||
// we're interested in a byte index, and the 255th index is not even valid
|
||||
// just wrap it back to 0
|
||||
|
||||
if (error_roots[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
field_operation_t loc = field_div(field, 1, error_roots[i]);
|
||||
for (field_operation_t j = 0; j < 256; j++) {
|
||||
if (field_pow(field, j, generator_root_gap) == loc) {
|
||||
error_locations[i] = field.log[j];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// erasure method -- take given locations and convert to roots
|
||||
// this is the inverse of reed_solomon_find_error_locations
|
||||
static void reed_solomon_find_error_roots_from_locations(field_t field, field_logarithm_t generator_root_gap,
|
||||
const field_logarithm_t *error_locations,
|
||||
field_element_t *error_roots, unsigned int num_errors) {
|
||||
for (unsigned int i = 0; i < num_errors; i++) {
|
||||
field_element_t loc = field_pow(field, field.exp[error_locations[i]], generator_root_gap);
|
||||
// field_element_t loc = field.exp[error_locations[i]];
|
||||
error_roots[i] = field_div(field, 1, loc);
|
||||
// error_roots[i] = loc;
|
||||
}
|
||||
}
|
||||
|
||||
// erasure method -- given the roots of the error locator, create the polynomial
|
||||
static polynomial_t reed_solomon_find_error_locator_from_roots(field_t field, unsigned int num_errors,
|
||||
field_element_t *error_roots,
|
||||
polynomial_t error_locator,
|
||||
polynomial_t *scratch) {
|
||||
// multiply out roots to build the error locator polynomial
|
||||
return polynomial_init_from_roots(field, num_errors, error_roots, error_locator, scratch);
|
||||
}
|
||||
|
||||
// erasure method
|
||||
static void reed_solomon_find_modified_syndromes(correct_reed_solomon *rs, field_element_t *syndromes, polynomial_t error_locator, field_element_t *modified_syndromes) {
|
||||
polynomial_t syndrome_poly;
|
||||
syndrome_poly.order = rs->min_distance - 1;
|
||||
syndrome_poly.coeff = syndromes;
|
||||
|
||||
polynomial_t modified_syndrome_poly;
|
||||
modified_syndrome_poly.order = rs->min_distance - 1;
|
||||
modified_syndrome_poly.coeff = modified_syndromes;
|
||||
|
||||
polynomial_mul(rs->field, error_locator, syndrome_poly, modified_syndrome_poly);
|
||||
}
|
||||
|
||||
void correct_reed_solomon_decoder_create(correct_reed_solomon *rs) {
|
||||
rs->has_init_decode = true;
|
||||
rs->syndromes = calloc(rs->min_distance, sizeof(field_element_t));
|
||||
rs->modified_syndromes = calloc(2 * rs->min_distance, sizeof(field_element_t));
|
||||
rs->received_polynomial = polynomial_create(rs->block_length - 1);
|
||||
rs->error_locator = polynomial_create(rs->min_distance);
|
||||
rs->error_locator_log = polynomial_create(rs->min_distance);
|
||||
rs->erasure_locator = polynomial_create(rs->min_distance);
|
||||
rs->error_roots = calloc(2 * rs->min_distance, sizeof(field_element_t));
|
||||
rs->error_vals = malloc(rs->min_distance * sizeof(field_element_t));
|
||||
rs->error_locations = malloc(rs->min_distance * sizeof(field_logarithm_t));
|
||||
|
||||
rs->last_error_locator = polynomial_create(rs->min_distance);
|
||||
rs->error_evaluator = polynomial_create(rs->min_distance - 1);
|
||||
rs->error_locator_derivative = polynomial_create(rs->min_distance - 1);
|
||||
|
||||
// calculate and store the first block_length powers of every generator root
|
||||
// we would have to do this work in order to calculate the syndromes
|
||||
// if we save it, we can prevent the need to recalculate it on subsequent calls
|
||||
// total memory usage is min_distance * block_length bytes e.g. 32 * 255 ~= 8k
|
||||
rs->generator_root_exp = malloc(rs->min_distance * sizeof(field_logarithm_t *));
|
||||
for (unsigned int i = 0; i < rs->min_distance; i++) {
|
||||
rs->generator_root_exp[i] = malloc(rs->block_length * sizeof(field_logarithm_t));
|
||||
polynomial_build_exp_lut(rs->field, rs->generator_roots[i], rs->block_length - 1, rs->generator_root_exp[i]);
|
||||
}
|
||||
|
||||
// calculate and store the first min_distance powers of every element in the field
|
||||
// we would have to do this for chien search anyway, and its size is only 256 * min_distance bytes
|
||||
// for min_distance = 32 this is 8k of memory, a pittance for the speedup we receive in exchange
|
||||
// we also get to reuse this work during error value calculation
|
||||
rs->element_exp = malloc(256 * sizeof(field_logarithm_t *));
|
||||
for (field_operation_t i = 0; i < 256; i++) {
|
||||
rs->element_exp[i] = malloc(rs->min_distance * sizeof(field_logarithm_t));
|
||||
polynomial_build_exp_lut(rs->field, i, rs->min_distance - 1, rs->element_exp[i]);
|
||||
}
|
||||
|
||||
rs->init_from_roots_scratch[0] = polynomial_create(rs->min_distance);
|
||||
rs->init_from_roots_scratch[1] = polynomial_create(rs->min_distance);
|
||||
}
|
||||
|
||||
ssize_t correct_reed_solomon_decode(correct_reed_solomon *rs, const uint8_t *encoded, size_t encoded_length,
|
||||
uint8_t *msg) {
|
||||
if (encoded_length > rs->block_length) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// the message is the non-remainder part
|
||||
size_t msg_length = encoded_length - rs->min_distance;
|
||||
// if they handed us a nonfull block, we'll write in 0s
|
||||
size_t pad_length = rs->block_length - encoded_length;
|
||||
|
||||
if (!rs->has_init_decode) {
|
||||
// initialize rs for decoding
|
||||
correct_reed_solomon_decoder_create(rs);
|
||||
}
|
||||
|
||||
// we need to copy to our local buffer
|
||||
// the buffer we're given has the coordinates in the wrong direction
|
||||
// e.g. byte 0 corresponds to the 254th order coefficient
|
||||
// so we're going to flip and then write padding
|
||||
// the final copied buffer will look like
|
||||
// | rem (rs->min_distance) | msg (msg_length) | pad (pad_length) |
|
||||
|
||||
for (unsigned int i = 0; i < encoded_length; i++) {
|
||||
rs->received_polynomial.coeff[i] = encoded[encoded_length - (i + 1)];
|
||||
}
|
||||
|
||||
// fill the pad_length with 0s
|
||||
for (unsigned int i = 0; i < pad_length; i++) {
|
||||
rs->received_polynomial.coeff[i + encoded_length] = 0;
|
||||
}
|
||||
|
||||
|
||||
bool all_zero = reed_solomon_find_syndromes(rs->field, rs->received_polynomial, rs->generator_root_exp,
|
||||
rs->syndromes, rs->min_distance);
|
||||
|
||||
if (all_zero) {
|
||||
// syndromes were all zero, so there was no error in the message
|
||||
// copy to msg and we are done
|
||||
for (unsigned int i = 0; i < msg_length; i++) {
|
||||
msg[i] = rs->received_polynomial.coeff[encoded_length - (i + 1)];
|
||||
}
|
||||
return msg_length;
|
||||
}
|
||||
|
||||
unsigned int order = reed_solomon_find_error_locator(rs, 0);
|
||||
// XXX fix this vvvv
|
||||
rs->error_locator.order = order;
|
||||
|
||||
for (unsigned int i = 0; i <= rs->error_locator.order; i++) {
|
||||
// this is a little strange since the coeffs are logs, not elements
|
||||
// also, we'll be storing log(0) = 0 for any 0 coeffs in the error locator
|
||||
// that would seem bad but we'll just be using this in chien search, and we'll skip all 0 coeffs
|
||||
// (you might point out that log(1) also = 0, which would seem to alias. however, that's ok,
|
||||
// because log(1) = 255 as well, and in fact that's how it's represented in our log table)
|
||||
rs->error_locator_log.coeff[i] = rs->field.log[rs->error_locator.coeff[i]];
|
||||
}
|
||||
rs->error_locator_log.order = rs->error_locator.order;
|
||||
|
||||
if (!reed_solomon_factorize_error_locator(rs->field, 0, rs->error_locator_log, rs->error_roots, rs->element_exp)) {
|
||||
// roots couldn't be found, so there were too many errors to deal with
|
||||
// RS has failed for this message
|
||||
return -1;
|
||||
}
|
||||
|
||||
reed_solomon_find_error_locations(rs->field, rs->generator_root_gap, rs->error_roots, rs->error_locations,
|
||||
rs->error_locator.order, 0);
|
||||
|
||||
reed_solomon_find_error_values(rs);
|
||||
|
||||
for (unsigned int i = 0; i < rs->error_locator.order; i++) {
|
||||
rs->received_polynomial.coeff[rs->error_locations[i]] =
|
||||
field_sub(rs->field, rs->received_polynomial.coeff[rs->error_locations[i]], rs->error_vals[i]);
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < msg_length; i++) {
|
||||
msg[i] = rs->received_polynomial.coeff[encoded_length - (i + 1)];
|
||||
}
|
||||
|
||||
return msg_length;
|
||||
}
|
||||
|
||||
ssize_t correct_reed_solomon_decode_with_erasures(correct_reed_solomon *rs, const uint8_t *encoded,
|
||||
size_t encoded_length, const uint8_t *erasure_locations,
|
||||
size_t erasure_length, uint8_t *msg) {
|
||||
if (!erasure_length) {
|
||||
return correct_reed_solomon_decode(rs, encoded, encoded_length, msg);
|
||||
}
|
||||
|
||||
if (encoded_length > rs->block_length) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (erasure_length > rs->min_distance) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// the message is the non-remainder part
|
||||
size_t msg_length = encoded_length - rs->min_distance;
|
||||
// if they handed us a nonfull block, we'll write in 0s
|
||||
size_t pad_length = rs->block_length - encoded_length;
|
||||
|
||||
if (!rs->has_init_decode) {
|
||||
// initialize rs for decoding
|
||||
correct_reed_solomon_decoder_create(rs);
|
||||
}
|
||||
|
||||
// we need to copy to our local buffer
|
||||
// the buffer we're given has the coordinates in the wrong direction
|
||||
// e.g. byte 0 corresponds to the 254th order coefficient
|
||||
// so we're going to flip and then write padding
|
||||
// the final copied buffer will look like
|
||||
// | rem (rs->min_distance) | msg (msg_length) | pad (pad_length) |
|
||||
|
||||
for (unsigned int i = 0; i < encoded_length; i++) {
|
||||
rs->received_polynomial.coeff[i] = encoded[encoded_length - (i + 1)];
|
||||
}
|
||||
|
||||
// fill the pad_length with 0s
|
||||
for (unsigned int i = 0; i < pad_length; i++) {
|
||||
rs->received_polynomial.coeff[i + encoded_length] = 0;
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < erasure_length; i++) {
|
||||
// remap the coordinates of the erasures
|
||||
rs->error_locations[i] = rs->block_length - (erasure_locations[i] + pad_length + 1);
|
||||
}
|
||||
|
||||
reed_solomon_find_error_roots_from_locations(rs->field, rs->generator_root_gap, rs->error_locations,
|
||||
rs->error_roots, erasure_length);
|
||||
|
||||
rs->erasure_locator =
|
||||
reed_solomon_find_error_locator_from_roots(rs->field, erasure_length, rs->error_roots, rs->erasure_locator, rs->init_from_roots_scratch);
|
||||
|
||||
bool all_zero = reed_solomon_find_syndromes(rs->field, rs->received_polynomial, rs->generator_root_exp,
|
||||
rs->syndromes, rs->min_distance);
|
||||
|
||||
if (all_zero) {
|
||||
// syndromes were all zero, so there was no error in the message
|
||||
// copy to msg and we are done
|
||||
for (unsigned int i = 0; i < msg_length; i++) {
|
||||
msg[i] = rs->received_polynomial.coeff[encoded_length - (i + 1)];
|
||||
}
|
||||
return msg_length;
|
||||
}
|
||||
|
||||
reed_solomon_find_modified_syndromes(rs, rs->syndromes, rs->erasure_locator, rs->modified_syndromes);
|
||||
|
||||
field_element_t *syndrome_copy = malloc(rs->min_distance * sizeof(field_element_t));
|
||||
memcpy(syndrome_copy, rs->syndromes, rs->min_distance * sizeof(field_element_t));
|
||||
|
||||
for (unsigned int i = erasure_length; i < rs->min_distance; i++) {
|
||||
rs->syndromes[i - erasure_length] = rs->modified_syndromes[i];
|
||||
}
|
||||
|
||||
unsigned int order = reed_solomon_find_error_locator(rs, erasure_length);
|
||||
// XXX fix this vvvv
|
||||
rs->error_locator.order = order;
|
||||
|
||||
for (unsigned int i = 0; i <= rs->error_locator.order; i++) {
|
||||
// this is a little strange since the coeffs are logs, not elements
|
||||
// also, we'll be storing log(0) = 0 for any 0 coeffs in the error locator
|
||||
// that would seem bad but we'll just be using this in chien search, and we'll skip all 0 coeffs
|
||||
// (you might point out that log(1) also = 0, which would seem to alias. however, that's ok,
|
||||
// because log(1) = 255 as well, and in fact that's how it's represented in our log table)
|
||||
rs->error_locator_log.coeff[i] = rs->field.log[rs->error_locator.coeff[i]];
|
||||
}
|
||||
rs->error_locator_log.order = rs->error_locator.order;
|
||||
|
||||
/*
|
||||
for (unsigned int i = 0; i < erasure_length; i++) {
|
||||
rs->error_roots[i] = field_div(rs->field, 1, rs->error_roots[i]);
|
||||
}
|
||||
*/
|
||||
|
||||
if (!reed_solomon_factorize_error_locator(rs->field, erasure_length, rs->error_locator_log, rs->error_roots, rs->element_exp)) {
|
||||
// roots couldn't be found, so there were too many errors to deal with
|
||||
// RS has failed for this message
|
||||
free(syndrome_copy);
|
||||
return -1;
|
||||
}
|
||||
|
||||
polynomial_t temp_poly = polynomial_create(rs->error_locator.order + erasure_length);
|
||||
polynomial_mul(rs->field, rs->erasure_locator, rs->error_locator, temp_poly);
|
||||
polynomial_t placeholder_poly = rs->error_locator;
|
||||
rs->error_locator = temp_poly;
|
||||
|
||||
reed_solomon_find_error_locations(rs->field, rs->generator_root_gap, rs->error_roots, rs->error_locations,
|
||||
rs->error_locator.order, erasure_length);
|
||||
|
||||
memcpy(rs->syndromes, syndrome_copy, rs->min_distance * sizeof(field_element_t));
|
||||
|
||||
reed_solomon_find_error_values(rs);
|
||||
|
||||
for (unsigned int i = 0; i < rs->error_locator.order; i++) {
|
||||
rs->received_polynomial.coeff[rs->error_locations[i]] =
|
||||
field_sub(rs->field, rs->received_polynomial.coeff[rs->error_locations[i]], rs->error_vals[i]);
|
||||
}
|
||||
|
||||
rs->error_locator = placeholder_poly;
|
||||
|
||||
for (unsigned int i = 0; i < msg_length; i++) {
|
||||
msg[i] = rs->received_polynomial.coeff[encoded_length - (i + 1)];
|
||||
}
|
||||
|
||||
polynomial_destroy(temp_poly);
|
||||
free(syndrome_copy);
|
||||
|
||||
return msg_length;
|
||||
}
|
||||
34
core/libcorrect/src/reed-solomon/encode.c
Normal file
34
core/libcorrect/src/reed-solomon/encode.c
Normal file
@ -0,0 +1,34 @@
|
||||
#include "correct/reed-solomon/encode.h"
|
||||
|
||||
ssize_t correct_reed_solomon_encode(correct_reed_solomon *rs, const uint8_t *msg, size_t msg_length, uint8_t *encoded) {
|
||||
if (msg_length > rs->message_length) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t pad_length = rs->message_length - msg_length;
|
||||
for (unsigned int i = 0; i < msg_length; i++) {
|
||||
// message goes from high order to low order but libcorrect polynomials go low to high
|
||||
// so we reverse on the way in and on the way out
|
||||
// we'd have to do a copy anyway so this reversal should be free
|
||||
rs->encoded_polynomial.coeff[rs->encoded_polynomial.order - (i + pad_length)] = msg[i];
|
||||
}
|
||||
|
||||
// 0-fill the rest of the coefficients -- this length will always be > 0
|
||||
// because the order of this poly is block_length and the msg_length <= message_length
|
||||
// e.g. 255 and 223
|
||||
memset(rs->encoded_polynomial.coeff + (rs->encoded_polynomial.order + 1 - pad_length), 0, pad_length);
|
||||
memset(rs->encoded_polynomial.coeff, 0, (rs->encoded_polynomial.order + 1 - rs->message_length));
|
||||
|
||||
polynomial_mod(rs->field, rs->encoded_polynomial, rs->generator, rs->encoded_remainder);
|
||||
|
||||
// now return byte order to highest order to lowest order
|
||||
for (unsigned int i = 0; i < msg_length; i++) {
|
||||
encoded[i] = rs->encoded_polynomial.coeff[rs->encoded_polynomial.order - (i + pad_length)];
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < rs->min_distance; i++) {
|
||||
encoded[msg_length + i] = rs->encoded_remainder.coeff[rs->min_distance - (i + 1)];
|
||||
}
|
||||
|
||||
return rs->block_length;
|
||||
}
|
||||
255
core/libcorrect/src/reed-solomon/polynomial.c
Normal file
255
core/libcorrect/src/reed-solomon/polynomial.c
Normal file
@ -0,0 +1,255 @@
|
||||
#include "correct/reed-solomon/polynomial.h"
|
||||
|
||||
polynomial_t polynomial_create(unsigned int order) {
|
||||
polynomial_t polynomial;
|
||||
polynomial.coeff = malloc(sizeof(field_element_t) * (order + 1));
|
||||
polynomial.order = order;
|
||||
return polynomial;
|
||||
}
|
||||
|
||||
void polynomial_destroy(polynomial_t polynomial) {
|
||||
free(polynomial.coeff);
|
||||
}
|
||||
|
||||
// if you want a full multiplication, then make res.order = l.order + r.order
|
||||
// but if you just care about a lower order, e.g. mul mod x^i, then you can select
|
||||
// fewer coefficients
|
||||
void polynomial_mul(field_t field, polynomial_t l, polynomial_t r, polynomial_t res) {
|
||||
// perform an element-wise multiplication of two polynomials
|
||||
memset(res.coeff, 0, sizeof(field_element_t) * (res.order + 1));
|
||||
for (unsigned int i = 0; i <= l.order; i++) {
|
||||
if (i > res.order) {
|
||||
continue;
|
||||
}
|
||||
unsigned int j_limit = (r.order > res.order - i) ? res.order - i : r.order;
|
||||
for (unsigned int j = 0; j <= j_limit; j++) {
|
||||
// e.g. alpha^5*x * alpha^37*x^2 --> alpha^42*x^3
|
||||
res.coeff[i + j] = field_add(field, res.coeff[i + j], field_mul(field, l.coeff[i], r.coeff[j]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void polynomial_mod(field_t field, polynomial_t dividend, polynomial_t divisor, polynomial_t mod) {
|
||||
// find the polynomial remainder of dividend mod divisor
|
||||
// do long division and return just the remainder (written to mod)
|
||||
|
||||
if (mod.order < dividend.order) {
|
||||
// mod.order must be >= dividend.order (scratch space needed)
|
||||
// this is an error -- catch it in debug?
|
||||
return;
|
||||
}
|
||||
// initialize remainder as dividend
|
||||
memcpy(mod.coeff, dividend.coeff, sizeof(field_element_t) * (dividend.order + 1));
|
||||
|
||||
// XXX make sure divisor[divisor_order] is nonzero
|
||||
field_logarithm_t divisor_leading = field.log[divisor.coeff[divisor.order]];
|
||||
// long division steps along one order at a time, starting at the highest order
|
||||
for (unsigned int i = dividend.order; i > 0; i--) {
|
||||
// look at the leading coefficient of dividend and divisor
|
||||
// if leading coefficient of dividend / leading coefficient of divisor is q
|
||||
// then the next row of subtraction will be q * divisor
|
||||
// if order of q < 0 then what we have is the remainder and we are done
|
||||
if (i < divisor.order) {
|
||||
break;
|
||||
}
|
||||
if (mod.coeff[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
unsigned int q_order = i - divisor.order;
|
||||
field_logarithm_t q_coeff = field_div_log(field, field.log[mod.coeff[i]], divisor_leading);
|
||||
|
||||
// now that we've chosen q, multiply the divisor by q and subtract from
|
||||
// our remainder. subtracting in GF(2^8) is XOR, just like addition
|
||||
for (unsigned int j = 0; j <= divisor.order; j++) {
|
||||
if (divisor.coeff[j] == 0) {
|
||||
continue;
|
||||
}
|
||||
// all of the multiplication is shifted up by q_order places
|
||||
mod.coeff[j + q_order] = field_add(field, mod.coeff[j + q_order],
|
||||
field_mul_log_element(field, field.log[divisor.coeff[j]], q_coeff));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void polynomial_formal_derivative(field_t field, polynomial_t poly, polynomial_t der) {
|
||||
// if f(x) = a(n)*x^n + ... + a(1)*x + a(0)
|
||||
// then f'(x) = n*a(n)*x^(n-1) + ... + 2*a(2)*x + a(1)
|
||||
// where n*a(n) = sum(k=1, n, a(n)) e.g. the nth sum of a(n) in GF(2^8)
|
||||
|
||||
// assumes der.order = poly.order - 1
|
||||
memset(der.coeff, 0, sizeof(field_element_t) * (der.order + 1));
|
||||
for (unsigned int i = 0; i <= der.order; i++) {
|
||||
// we're filling in the ith power of der, so we look ahead one power in poly
|
||||
// f(x) = a(i + 1)*x^(i + 1) -> f'(x) = (i + 1)*a(i + 1)*x^i
|
||||
// where (i + 1)*a(i + 1) is the sum of a(i + 1) (i + 1) times, not the product
|
||||
der.coeff[i] = field_sum(field, poly.coeff[i + 1], i + 1);
|
||||
}
|
||||
}
|
||||
|
||||
field_element_t polynomial_eval(field_t field, polynomial_t poly, field_element_t val) {
|
||||
// evaluate the polynomial poly at a particular element val
|
||||
if (val == 0) {
|
||||
return poly.coeff[0];
|
||||
}
|
||||
|
||||
field_element_t res = 0;
|
||||
|
||||
// we're going to start at 0th order and multiply by val each time
|
||||
field_logarithm_t val_exponentiated = field.log[1];
|
||||
field_logarithm_t val_log = field.log[val];
|
||||
|
||||
for (unsigned int i = 0; i <= poly.order; i++) {
|
||||
if (poly.coeff[i] != 0) {
|
||||
// multiply-accumulate by the next coeff times the next power of val
|
||||
res = field_add(field, res,
|
||||
field_mul_log_element(field, field.log[poly.coeff[i]], val_exponentiated));
|
||||
}
|
||||
// now advance to the next power
|
||||
val_exponentiated = field_mul_log(field, val_exponentiated, val_log);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
field_element_t polynomial_eval_lut(field_t field, polynomial_t poly, const field_logarithm_t *val_exp) {
|
||||
// evaluate the polynomial poly at a particular element val
|
||||
// in this case, all of the logarithms of the successive powers of val have been precalculated
|
||||
// this removes the extra work we'd have to do to calculate val_exponentiated each time
|
||||
// if this function is to be called on the same val multiple times
|
||||
if (val_exp[0] == 0) {
|
||||
return poly.coeff[0];
|
||||
}
|
||||
|
||||
field_element_t res = 0;
|
||||
|
||||
for (unsigned int i = 0; i <= poly.order; i++) {
|
||||
if (poly.coeff[i] != 0) {
|
||||
// multiply-accumulate by the next coeff times the next power of val
|
||||
res = field_add(field, res,
|
||||
field_mul_log_element(field, field.log[poly.coeff[i]], val_exp[i]));
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
field_element_t polynomial_eval_log_lut(field_t field, polynomial_t poly_log, const field_logarithm_t *val_exp) {
|
||||
// evaluate the log_polynomial poly at a particular element val
|
||||
// like polynomial_eval_lut, the logarithms of the successive powers of val have been
|
||||
// precomputed
|
||||
if (val_exp[0] == 0) {
|
||||
if (poly_log.coeff[0] == 0) {
|
||||
// special case for the non-existant log case
|
||||
return 0;
|
||||
}
|
||||
return field.exp[poly_log.coeff[0]];
|
||||
}
|
||||
|
||||
field_element_t res = 0;
|
||||
|
||||
for (unsigned int i = 0; i <= poly_log.order; i++) {
|
||||
// using 0 as a sentinel value in log -- log(0) is really -inf
|
||||
if (poly_log.coeff[i] != 0) {
|
||||
// multiply-accumulate by the next coeff times the next power of val
|
||||
res = field_add(field, res,
|
||||
field_mul_log_element(field, poly_log.coeff[i], val_exp[i]));
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
void polynomial_build_exp_lut(field_t field, field_element_t val, unsigned int order, field_logarithm_t *val_exp) {
|
||||
// create the lookup table of successive powers of val used by polynomial_eval_lut
|
||||
field_logarithm_t val_exponentiated = field.log[1];
|
||||
field_logarithm_t val_log = field.log[val];
|
||||
for (unsigned int i = 0; i <= order; i++) {
|
||||
if (val == 0) {
|
||||
val_exp[i] = 0;
|
||||
} else {
|
||||
val_exp[i] = val_exponentiated;
|
||||
val_exponentiated = field_mul_log(field, val_exponentiated, val_log);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
polynomial_t polynomial_init_from_roots(field_t field, unsigned int nroots, field_element_t *roots, polynomial_t poly, polynomial_t *scratch) {
|
||||
unsigned int order = nroots;
|
||||
polynomial_t l;
|
||||
field_element_t l_coeff[2];
|
||||
l.order = 1;
|
||||
l.coeff = l_coeff;
|
||||
|
||||
// we'll keep two temporary stores of rightside polynomial
|
||||
// each time through the loop, we take the previous result and use it as new rightside
|
||||
// swap back and forth (prevents the need for a copy)
|
||||
polynomial_t r[2];
|
||||
r[0] = scratch[0];
|
||||
r[1] = scratch[1];
|
||||
unsigned int rcoeffres = 0;
|
||||
|
||||
// initialize the result with x + roots[0]
|
||||
r[rcoeffres].coeff[1] = 1;
|
||||
r[rcoeffres].coeff[0] = roots[0];
|
||||
r[rcoeffres].order = 1;
|
||||
|
||||
// initialize lcoeff[1] with x
|
||||
// we'll fill in the 0th order term in each loop iter
|
||||
l.coeff[1] = 1;
|
||||
|
||||
// loop through, using previous run's result as the new right hand side
|
||||
// this allows us to multiply one group at a time
|
||||
for (unsigned int i = 1; i < nroots; i++) {
|
||||
l.coeff[0] = roots[i];
|
||||
unsigned int nextrcoeff = rcoeffres;
|
||||
rcoeffres = (rcoeffres + 1) % 2;
|
||||
r[rcoeffres].order = i + 1;
|
||||
polynomial_mul(field, l, r[nextrcoeff], r[rcoeffres]);
|
||||
}
|
||||
|
||||
memcpy(poly.coeff, r[rcoeffres].coeff, (order + 1) * sizeof(field_element_t));
|
||||
poly.order = order;
|
||||
|
||||
return poly;
|
||||
}
|
||||
|
||||
polynomial_t polynomial_create_from_roots(field_t field, unsigned int nroots, field_element_t *roots) {
|
||||
polynomial_t poly = polynomial_create(nroots);
|
||||
unsigned int order = nroots;
|
||||
polynomial_t l;
|
||||
l.order = 1;
|
||||
l.coeff = calloc(2, sizeof(field_element_t));
|
||||
|
||||
polynomial_t r[2];
|
||||
// we'll keep two temporary stores of rightside polynomial
|
||||
// each time through the loop, we take the previous result and use it as new rightside
|
||||
// swap back and forth (prevents the need for a copy)
|
||||
r[0].coeff = calloc(order + 1, sizeof(field_element_t));
|
||||
r[1].coeff = calloc(order + 1, sizeof(field_element_t));
|
||||
unsigned int rcoeffres = 0;
|
||||
|
||||
// initialize the result with x + roots[0]
|
||||
r[rcoeffres].coeff[0] = roots[0];
|
||||
r[rcoeffres].coeff[1] = 1;
|
||||
r[rcoeffres].order = 1;
|
||||
|
||||
// initialize lcoeff[1] with x
|
||||
// we'll fill in the 0th order term in each loop iter
|
||||
l.coeff[1] = 1;
|
||||
|
||||
// loop through, using previous run's result as the new right hand side
|
||||
// this allows us to multiply one group at a time
|
||||
for (unsigned int i = 1; i < nroots; i++) {
|
||||
l.coeff[0] = roots[i];
|
||||
unsigned int nextrcoeff = rcoeffres;
|
||||
rcoeffres = (rcoeffres + 1) % 2;
|
||||
r[rcoeffres].order = i + 1;
|
||||
polynomial_mul(field, l, r[nextrcoeff], r[rcoeffres]);
|
||||
}
|
||||
|
||||
memcpy(poly.coeff, r[rcoeffres].coeff, (order + 1) * sizeof(field_element_t));
|
||||
poly.order = order;
|
||||
|
||||
free(l.coeff);
|
||||
free(r[0].coeff);
|
||||
free(r[1].coeff);
|
||||
|
||||
return poly;
|
||||
}
|
||||
187
core/libcorrect/src/reed-solomon/reed-solomon.c
Normal file
187
core/libcorrect/src/reed-solomon/reed-solomon.c
Normal file
@ -0,0 +1,187 @@
|
||||
#include "correct/reed-solomon/reed-solomon.h"
|
||||
|
||||
// coeff must be of size nroots + 1
|
||||
// e.g. 2 roots (x + alpha)(x + alpha^2) yields a poly with 3 terms x^2 + g0*x + g1
|
||||
static polynomial_t reed_solomon_build_generator(field_t field, unsigned int nroots, field_element_t first_consecutive_root, unsigned int root_gap, polynomial_t generator, field_element_t *roots) {
|
||||
// generator has order 2*t
|
||||
// of form (x + alpha^1)(x + alpha^2)...(x - alpha^2*t)
|
||||
for (unsigned int i = 0; i < nroots; i++) {
|
||||
roots[i] = field.exp[(root_gap * (i + first_consecutive_root)) % 255];
|
||||
}
|
||||
return polynomial_create_from_roots(field, nroots, roots);
|
||||
}
|
||||
|
||||
correct_reed_solomon *correct_reed_solomon_create(field_operation_t primitive_polynomial, field_logarithm_t first_consecutive_root, field_logarithm_t generator_root_gap, size_t num_roots) {
|
||||
correct_reed_solomon *rs = calloc(1, sizeof(correct_reed_solomon));
|
||||
rs->field = field_create(primitive_polynomial);
|
||||
|
||||
rs->block_length = 255;
|
||||
rs->min_distance = num_roots;
|
||||
rs->message_length = rs->block_length - rs->min_distance;
|
||||
|
||||
rs->first_consecutive_root = first_consecutive_root;
|
||||
rs->generator_root_gap = generator_root_gap;
|
||||
|
||||
rs->generator_roots = malloc(rs->min_distance * sizeof(field_element_t));
|
||||
|
||||
rs->generator = reed_solomon_build_generator(rs->field, rs->min_distance, rs->first_consecutive_root, rs->generator_root_gap, rs->generator, rs->generator_roots);
|
||||
|
||||
rs->encoded_polynomial = polynomial_create(rs->block_length - 1);
|
||||
rs->encoded_remainder = polynomial_create(rs->block_length - 1);
|
||||
|
||||
rs->has_init_decode = false;
|
||||
|
||||
return rs;
|
||||
}
|
||||
|
||||
void correct_reed_solomon_destroy(correct_reed_solomon *rs) {
|
||||
field_destroy(rs->field);
|
||||
polynomial_destroy(rs->generator);
|
||||
free(rs->generator_roots);
|
||||
polynomial_destroy(rs->encoded_polynomial);
|
||||
polynomial_destroy(rs->encoded_remainder);
|
||||
if (rs->has_init_decode) {
|
||||
free(rs->syndromes);
|
||||
free(rs->modified_syndromes);
|
||||
polynomial_destroy(rs->received_polynomial);
|
||||
polynomial_destroy(rs->error_locator);
|
||||
polynomial_destroy(rs->error_locator_log);
|
||||
polynomial_destroy(rs->erasure_locator);
|
||||
free(rs->error_roots);
|
||||
free(rs->error_vals);
|
||||
free(rs->error_locations);
|
||||
polynomial_destroy(rs->last_error_locator);
|
||||
polynomial_destroy(rs->error_evaluator);
|
||||
polynomial_destroy(rs->error_locator_derivative);
|
||||
for (unsigned int i = 0; i < rs->min_distance; i++) {
|
||||
free(rs->generator_root_exp[i]);
|
||||
}
|
||||
free(rs->generator_root_exp);
|
||||
for (field_operation_t i = 0; i < 256; i++) {
|
||||
free(rs->element_exp[i]);
|
||||
}
|
||||
free(rs->element_exp);
|
||||
polynomial_destroy(rs->init_from_roots_scratch[0]);
|
||||
polynomial_destroy(rs->init_from_roots_scratch[1]);
|
||||
}
|
||||
free(rs);
|
||||
}
|
||||
|
||||
void correct_reed_solomon_debug_print(correct_reed_solomon *rs) {
|
||||
for (unsigned int i = 0; i < 256; i++) {
|
||||
printf("%3d %3d %3d %3d\n", i, rs->field.exp[i], i, rs->field.log[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
printf("roots: ");
|
||||
for (unsigned int i = 0; i < rs->min_distance; i++) {
|
||||
printf("%d", rs->generator_roots[i]);
|
||||
if (i < rs->min_distance - 1) {
|
||||
printf(", ");
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("generator: ");
|
||||
for (unsigned int i = 0; i < rs->generator.order + 1; i++) {
|
||||
printf("%d*x^%d", rs->generator.coeff[i], i);
|
||||
if (i < rs->generator.order) {
|
||||
printf(" + ");
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("generator (alpha format): ");
|
||||
for (unsigned int i = rs->generator.order + 1; i > 0; i--) {
|
||||
printf("alpha^%d*x^%d", rs->field.log[rs->generator.coeff[i - 1]], i - 1);
|
||||
if (i > 1) {
|
||||
printf(" + ");
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("remainder: ");
|
||||
bool has_printed = false;
|
||||
for (unsigned int i = 0; i < rs->encoded_remainder.order + 1; i++) {
|
||||
if (!rs->encoded_remainder.coeff[i]) {
|
||||
continue;
|
||||
}
|
||||
if (has_printed) {
|
||||
printf(" + ");
|
||||
}
|
||||
has_printed = true;
|
||||
printf("%d*x^%d", rs->encoded_remainder.coeff[i], i);
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("syndromes: ");
|
||||
for (unsigned int i = 0; i < rs->min_distance; i++) {
|
||||
printf("%d", rs->syndromes[i]);
|
||||
if (i < rs->min_distance - 1) {
|
||||
printf(", ");
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("numerrors: %d\n\n", rs->error_locator.order);
|
||||
|
||||
printf("error locator: ");
|
||||
has_printed = false;
|
||||
for (unsigned int i = 0; i < rs->error_locator.order + 1; i++) {
|
||||
if (!rs->error_locator.coeff[i]) {
|
||||
continue;
|
||||
}
|
||||
if (has_printed) {
|
||||
printf(" + ");
|
||||
}
|
||||
has_printed = true;
|
||||
printf("%d*x^%d", rs->error_locator.coeff[i], i);
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("error roots: ");
|
||||
for (unsigned int i = 0; i < rs->error_locator.order; i++) {
|
||||
printf("%d@%d", polynomial_eval(rs->field, rs->error_locator, rs->error_roots[i]), rs->error_roots[i]);
|
||||
if (i < rs->error_locator.order - 1) {
|
||||
printf(", ");
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("error evaluator: ");
|
||||
has_printed = false;
|
||||
for (unsigned int i = 0; i < rs->error_evaluator.order; i++) {
|
||||
if (!rs->error_evaluator.coeff[i]) {
|
||||
continue;
|
||||
}
|
||||
if (has_printed) {
|
||||
printf(" + ");
|
||||
}
|
||||
has_printed = true;
|
||||
printf("%d*x^%d", rs->error_evaluator.coeff[i], i);
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("error locator derivative: ");
|
||||
has_printed = false;
|
||||
for (unsigned int i = 0; i < rs->error_locator_derivative.order; i++) {
|
||||
if (!rs->error_locator_derivative.coeff[i]) {
|
||||
continue;
|
||||
}
|
||||
if (has_printed) {
|
||||
printf(" + ");
|
||||
}
|
||||
has_printed = true;
|
||||
printf("%d*x^%d", rs->error_locator_derivative.coeff[i], i);
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
printf("error locator: ");
|
||||
for (unsigned int i = 0; i < rs->error_locator.order; i++) {
|
||||
printf("%d@%d", rs->error_vals[i], rs->error_locations[i]);
|
||||
if (i < rs->error_locator.order - 1) {
|
||||
printf(", ");
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
}
|
||||
Reference in New Issue
Block a user