/* From Cain, Clark, "Error-Correction Coding For Digital Communications", pp. 216. */
void
Modified_Berlekamp_Massey (void)
{
int n, L, L2, k, d, i;
int psi[MAXDEG], psi2[MAXDEG], D[MAXDEG];
int gamma[MAXDEG];
/* initialize Gamma, the erasure locator polynomial */
init_gamma(gamma);
/* initialize to z */
copy_poly(D, gamma);
mul_z_poly(D);
copy_poly(psi, gamma);
k = -1;
L = NErasures;
for (n = NErasures; n < NPAR; n++) {
d = compute_discrepancy(psi, synBytes, L, n);
if (d != 0) {
/* psi2 = psi - d*D */
for (i = 0; i < MAXDEG; i++) psi2[i] = psi[i] ^ gmult(d, D[i]);
if (L < (n-k)) {
L2 = n-k;
k = n-L;
/* D = scale_poly(ginv(d), psi); */
for (i = 0; i < MAXDEG; i++) D[i] = gmult(psi[i], ginv(d));
L = L2;
}
/* psi = psi2 */
for (i = 0; i < MAXDEG; i++) psi[i] = psi2[i];
}
mul_z_poly(D);
}
for(i = 0; i < MAXDEG; i++) Lambda[i] = psi[i];
compute_modified_omega();
}
void CReedSolomon::Modified_Berlekamp_Massey (void) {
int L, L2, k, d;
int psi [MAX_LENGTH], psi2 [MAX_LENGTH], D [MAX_LENGTH];
int gamma [MAX_LENGTH];
int iMaxLength = m_iCorrectCodeSize * 2;
/* initialize Gamma, the erasure locator polynomial */
init_gamma (gamma);
/* initialize to z */
copy_poly (D, gamma);
mul_z_poly (D);
copy_poly (psi, gamma);
k = -1;
L = m_NErasures;
for (int n = m_NErasures; n < m_iCorrectCodeSize; n ++) {
d = compute_discrepancy (psi, m_synBytes, L, n);
if (d != 0) {
/* psi2 = psi - d*D */
for (int i = 0; i < iMaxLength; i++) {
psi2 [i] = psi [i] ^ gmult (d, D [i]);
}
if (L < (n - k)) {
L2 = n - k;
k = n - L;
/* D = scale_poly(ginv(d), psi); */
for (int i = 0; i < iMaxLength; i ++) {
D [i] = gmult (psi [i], ginv (d));
}
L = L2;
}
/* psi = psi2 */
for (int i = 0; i < iMaxLength; i ++) {
psi [i] = psi2 [i];
}
}
mul_z_poly (D);
}
for (int i = 0; i < MAX_LENGTH; i ++) {
m_Lambda [i] = psi [i];
}
compute_modified_omega ();
}
void convert_ksprop_to_wprop_swv(spin_wilson_vector *swv,
su3_vector *ksp, int r[], int r0[])
{
int i;
site *s;
gamma_matrix_t gamma0;
init_gamma();
/* Construct source gamma adjoint */
gamma0 = g1; /* Unit gamma */
mult_omega_l(&gamma0, r[0]-r0[0], r[1]-r0[1], r[2]-r0[2], r[3]-r0[3]);
gamma_adj(&gamma0_dag, &gamma0);
FORALLSITES(i,s){
m_by_omega_swv( swv+i, ksp+i, s, r0);
}
// Given alf, the parameter α of the Laguerre polynomials, this routine
// returns arrays x[1..n] and w[1..n] containing the abscissas and weights
// of the n-point Gauss-Laguerre quadrature formula. The smallest abscissa is
// returned in x[1], the largest in x[n].
void gaulag(double x[], double w[], int n, int alf)
{
int i, its, j;
double ai;
double p1,p2,p3,pp,z,z1; // High precision is a good idea for this routine.
init_gamma();
for (i = 1; i <= n; i++) { // Loop over the desired roots.
if (i == 1) { // Initial guess for the smallest root.
z=(1.0+alf)*(3.0+0.92*alf)/(1.0+2.4*n+1.8*alf);
} else if (i == 2) { // Initial guess for the second root.
z += (15.0+6.25*alf)/(1.0+0.9*alf+2.5*n);
} else { // Initial guess for the other roots.
ai=i-2;
z += ((1.0+2.55*ai)/(1.9*ai)+1.26*ai*alf/
(1.0+3.5*ai))*(z-x[i-2])/(1.0+0.3*alf);
}
for (its=1;its<=MAXIT;its++) { // Refinement by Newton’s method.
p1=1.0;
p2=0.0;
for (j=1;j<=n;j++) { // Loop up the recurrence relation to get the
p3=p2; // Laguerre polynomial evaluated at z.
p2=p1;
p1=((2*j-1+alf-z)*p2-(j-1+alf)*p3)/j;
}
// p1 is now the desired Laguerre polynomial. We next compute pp,
// its derivative, by a standard relation involving also p2,
// the polynomial of one lower order.
pp=(n*p1-(n+alf)*p2)/z;
z1=z;
z=z1-p1/pp; // Newton’s formula.
if (fabs(z-z1) <= EPS) break;
}
if (its > MAXIT) nrerror("too many iterations in gaulag");
x[i]=z; // Store the root and the weight.
w[i] = -exp(gammaln[alf+n]-gammaln[n])/(pp*n*p2);
}
}
