// Top level decoder module
void rs_decode (unsigned char n, unsigned char t, unsigned char in_d[nn],
unsigned char *k, unsigned char out_d[kk])
{
unsigned char temp_k = n - 2*t;
unsigned char s[2*tt];
unsigned char c[tt+2];
unsigned char w[tt+2];
unsigned char lambda[tt];
unsigned char omega[tt];
unsigned char err_no;
unsigned char err_loc[kk];
unsigned char alpha_inv[tt];
unsigned char err[kk];
unsigned char in_data[kk];
unsigned char in_d_2[nn];
Simple_rs1: for (int i = 0; i < nn; i++)
in_d_2[i] = in_d[i];
*k = temp_k;
rs_fifo(temp_k, in_d, in_data);
syndrome(temp_k, t, in_d_2, s);
berlekamp(t, s, lambda, omega);
chien_search(kk, tt, lambda, &err_no, err_loc, alpha_inv);
error_mag(kk, lambda, omega, err_no, err_loc, alpha_inv, err);
error_correct(temp_k, in_data, err, out_d);
}
FPoly_t *Factorization(const Poly_t *pol)
{
factor_t *list, *l;
FPoly_t *factors;
/* Allocate result
--------------- */
if ((factors = FpAlloc()) == NULL)
{
MTX_ERROR("Cannot allocate result");
return NULL;
}
/* Step 1: Squarefree factorization
-------------------------------- */
if ((list = factorsquarefree(pol)) == NULL)
{
MTX_ERROR("Squarefree factorization failed");
return NULL;
}
/* Step 2: Decompose the squarefree factors using Berlekamp's algorithm
-------------------------------------------------------------------- */
for (l = list; l->p != NULL; ++l)
{
Matrix_t *kernel;
Poly_t **irr, **i;
kernel = makekernel(l->p);
if ((irr = berlekamp(l->p,kernel)) == NULL)
{
MTX_ERROR("Berlekamp factorization failed");
return NULL;
}
MatFree(kernel);
for (i = irr; *i != NULL; ++i)
{
FpMulP(factors,*i,l->n);
PolFree(*i);
}
/* Clean up
-------- */
SysFree(irr);
PolFree(l->p);
}
/* Clean up
-------- */
SysFree(list);
return factors;
}
int main()
{
long NumContexts = 3;
long NumPolys = 6;
long n = 500;
Vec<ZZ_pContext> context_vec;
context_vec.SetLength(NumContexts);
long i;
for (i = 0; i < NumContexts; i++) {
ZZ p;
RandomPrime(p, 150 + i*50);
context_vec[i] = ZZ_pContext(p);
}
Vec<ZZ_pX> poly_vec;
Vec<vec_pair_ZZ_pX_long> res_vec;
Vec< SmartPtr<thread> > thread_vec;
poly_vec.SetLength(NumPolys);
res_vec.SetLength(NumPolys);
thread_vec.SetLength(NumPolys);
for (i = 0; i < NumPolys; i++) {
ZZ_pPush push(context_vec[i % NumContexts]);
random(poly_vec[i], n);
SetCoeff(poly_vec[i], n);
}
cerr << "START\n";
for (i = 0; i < NumPolys; i++)
thread_vec[i] = MakeSmart<thread>(task, context_vec[i % NumContexts],
&poly_vec[i], &res_vec[i]);
for (i = 0; i < NumPolys; i++)
thread_vec[i]->join();
cerr << "checking results...\n";
for (i = 0; i < NumPolys; i++) {
ZZ_pPush push(context_vec[i % NumContexts]);
vec_pair_ZZ_pX_long v;
berlekamp(v, poly_vec[i]);
if (v.length() == res_vec[i].length() && mul(v) == mul(res_vec[i]))
cerr << i << " GOOD\n";
else
cerr << i << " BAD\n";
}
}
static void ZZ_pX_factor(struct ZZ_pX*** v, long** e, long* n, struct ZZ_pX* x, long verbose)
{
long i;
vec_pair_ZZ_pX_long factors;
berlekamp(factors, *x, verbose);
*n = factors.length();
*v = (ZZ_pX**) malloc(sizeof(ZZ_pX*) * (*n));
*e = (long*) malloc(sizeof(long)*(*n));
for (i=0; i<(*n); i++) {
(*v)[i] = new ZZ_pX(factors[i].a);
(*e)[i] = factors[i].b;
}
}
int main()
{
ZZ p;
cin >> p;
ZZ_p::init(p);
ZZ_pX f;
cin >> f;
vec_pair_ZZ_pX_long factors;
double t = GetTime();
berlekamp(factors, f, 1);
t = GetTime()-t;
cerr << "total time: " << t << "\n";
ZZ_pX ff;
mul(ff, factors);
if (f != ff)
Error("Incorrect factorization!!");
sort(factors);
cerr << "factorization pattern:";
long i;
for (i = 0; i < factors.length(); i++) {
cerr << " ";
long k = factors[i].b;
if (k > 1)
cerr << k << "*";
cerr << deg(factors[i].a);
}
cerr << "\n";
cout << factors << "\n";
return 0;
}
