GF *GF::create(const RingElement *prim)
{
GF *result = new GF;
if (!result->initialize_GF(prim)) return 0;
return result;
}
int bose(GF & gf, bclib::matrix<int> & A, int ncol)
{
size_t icol, irow;
size_t q = static_cast<size_t>(gf.q);
// bosecheck throws if it fails
bosecheck(static_cast<int>(q), ncol);
irow = 0;
for (size_t i = 0; i < q; i++)
{
for (size_t j = 0; j < q; j++)
{
icol = 0;
A(irow, icol++) = static_cast<int>(i);
if (ncol > 1)
{
A(irow, icol++) = static_cast<int>(j);
}
for (icol = 2; icol < static_cast<size_t>(ncol); icol++)
{
A(irow, icol) = gf.plus(j, gf.times(i, icol - 1));
}
irow++;
}
}
return SUCCESS_CHECK;
}
/* find value = poly(arg) where poly is a polynomial of degree d
and all the arithmetic takes place in the given Galois field.*/
int polyeval(GF & gf, int d, std::vector<int> & poly, int arg, int* value)
{
int ans = 0;
/* note: cannot decrement with a size type because it is always > 0. this needs to go < 1 to stop */
//for (size_t i = static_cast<size_t>(d); i >= 0; --i) /* Horner's rule */
for (int i = d; i >= 0; i--) /* Horner's rule */
{
size_t ui = static_cast<size_t>(i);
size_t uans = static_cast<size_t>(ans);
size_t uarg = static_cast<size_t>(arg);
#ifdef RANGE_DEBUG
size_t plusRow = static_cast<size_t>(gf.times.at(uans,uarg));
size_t plusCol = static_cast<size_t>(poly.at(ui));
ans = gf.plus.at(plusRow, plusCol);
#else
//ans = gf.plus(gf.times(ans,arg),poly[i]);
size_t plusRow = static_cast<size_t>(gf.times(uans,uarg));
size_t plusCol = static_cast<size_t>(poly[ui]);
ans = gf.plus(plusRow, plusCol);
#endif
}
*value = ans;
return UNCHECKED_RETURN;
}
void CCodeCalcForm::OnBnClickedButton9()
{
int uID;
uID=GetCheckedRadioButton(IDC_RADIO8,IDC_RADIO9);
if(uID==IDC_RADIO8)
{
XTIME xtime;
xtime.DoModal();
}
else if(uID==IDC_RADIO9)
{
GF gf;
gf.DoModal();
}
else
MessageBox("请选择算法！");
}
void Reed_Solomon::encode(const bvec &uncoded_bits, bvec &coded_bits)
{
int i, j, iterations = floor_i(static_cast<double>(uncoded_bits.length())
/ (k * m));
GFX mx(q, k), cx(q, n);
GFX r(n + 1, n - k);
GFX uncoded_shifted(n + 1, n);
GF mpow;
bvec mbit(k * m), cbit(m);
coded_bits.set_size(iterations * n * m, false);
if (systematic)
for (i = 0; i < n - k; i++)
uncoded_shifted[i] = GF(n + 1, -1);
for (i = 0; i < iterations; i++) {
//Fix the message polynom m(x).
for (j = 0; j < k; j++) {
mpow.set(q, uncoded_bits.mid((i * m * k) + (j * m), m));
mx[j] = mpow;
if (systematic) {
cx[j] = mx[j];
uncoded_shifted[j + n - k] = mx[j];
}
}
//Fix the outputbits cbit.
if (systematic) {
r = modgfx(uncoded_shifted, g);
for (j = k; j < n; j++) {
cx[j] = r[j - k];
}
}
else {
cx = g * mx;
}
for (j = 0; j < n; j++) {
cbit = cx[j].get_vectorspace();
coded_bits.replace_mid((i * n * m) + (j * m), cbit);
}
}
}
int bosebushl(GF & gf, int lam, bclib::matrix<int> & B, int ncol)
/* Implement Bose and Bush's 1952 A.M.S. method with given lambda */
{
int p, irow;
int mul;
p = gf.p; /* GF(q) used to generate design with q/lam levels */
size_t q = static_cast<size_t>(gf.q);
size_t s = q / lam; /* number of levels in design */
bclib::matrix<int> A(s,q);
// bosebushlcheck throws if it fails
bosebushlcheck(static_cast<int>(s), p, lam, ncol);
irow = 0;
for (size_t i = 0; i < q; i++)
{
for (size_t j = 0; j < q; j++)
{
mul = gf.times(i,j);
mul = mul % s;
for (size_t k = 0; k < s; k++)
{
A(k,j) = gf.plus(mul,k);
}
}
for (size_t k = 0; k < s; k++)
{
for (size_t j = 0; j < static_cast<size_t>(ncol) && j < lam * s + 1; j++)
{
B(irow,j) = A(k,j);
}
if (ncol == lam * static_cast<int>(s) + 1)
{
B(irow, static_cast<size_t>(ncol) - 1) = static_cast<int>(i % s);
}
irow++;
}
}
return SUCCESS_CHECK;
}
int bosebush(GF & gf, bclib::matrix<int> & B, int ncol)
{
int p;
int mul;
size_t irow;
p = gf.p; /* GF(q) used to generate design with q/2 levels */
size_t q = static_cast<size_t>(gf.q);
size_t s = q / 2; /* number of levels in design */
bclib::matrix<int> A(s, q);
// bosebushcheck throws if it fails
bosebushcheck(static_cast<int>(s), p, ncol);
irow = 0;
for (size_t i = 0; i < q; i++)
{
for (size_t j = 0; j < q; j++)
{
mul = gf.times(i,j);
mul = mul % s;
for (size_t k = 0; k < s; k++)
{
A(k,j) = gf.plus(mul,k);
}
}
for (size_t k = 0; k < s; k++)
{
for (size_t j = 0; j < static_cast<size_t>(ncol) && j < 2 * s + 1; j++)
{
B(irow,j) = A(k,j);
}
if (static_cast<size_t>(ncol) == 2 * s + 1)
{
B(irow, static_cast<size_t>(ncol) - 1) = static_cast<int>(i % s);
}
irow++;
}
}
return SUCCESS_CHECK;
}
void CCodeCalcForm::OnBnClickedButton1()
{
// TODO: 在此添加控件通知处理程序代码
int uID;
uID=GetCheckedRadioButton(IDC_RADIO1,IDC_RADIO4);
if(uID==IDC_RADIO1)
{
Euclid euclid;
euclid.DoModal();
}
else if(uID==IDC_RADIO3)
{
XTIME xtime;
xtime.DoModal();
}
else if(uID==IDC_RADIO4)
{
GF gf;
gf.DoModal();
}
else
MessageBox("请选择算法！");
}
void GF_print(GF & gf)
{
int n, p, q;
n = gf.n;
p = gf.p;
q = gf.q;
if (q > 999)
{
PRINT_OUTPUT("Warning q=%d will overflow print field.\n", q);
}
PRINT_OUTPUT("\nFor GF(%d) p=%d n=%d\n", q, p, n);
PRINT_OUTPUT("x**n = (");
for (int i = 0; i < n - 1; i++)
{
PRINT_OUTPUT("%d,", gf.xton[i]);
}
PRINT_OUTPUT("%d)\n", gf.xton[n - 1]);
PRINT_OUTPUT("\n\nGF(%d) Polynomial coefficients:\n", q);
for (int i = 0; i < q; i++)
{
PRINT_OUTPUT(" %3d ", i);
for (int j = 0; j < n; j++)
{
PRINT_OUTPUT("%3d ", gf.poly(i,j));
}
PRINT_OUTPUT("\n");
}
PRINT_OUTPUT("\n\nGF(%d) Addition Table\n", q);
for (int i = 0; i < q; i++)
{
PRINT_OUTPUT(" ");
for (int j = 0; j < q; j++)
{
PRINT_OUTPUT(" %3d", gf.plus(i,j));
}
PRINT_OUTPUT("\n");
}
PRINT_OUTPUT("\n\nGF(%d) Multiplication table\n", q);
for (int i = 0; i < q; i++)
{
PRINT_OUTPUT(" ");
for (int j = 0; j < q; j++)
{
PRINT_OUTPUT(" %3d", gf.times(i,j));
}
PRINT_OUTPUT("\n");
}
PRINT_OUTPUT("\n\nGF(%d) Reciprocals\n", q);
for (int i = 1; i < q; i++)
{
PRINT_OUTPUT(" %3d %3d\n", i, gf.inv[i]);
}
PRINT_OUTPUT("\n\nGF(%d) Negatives\n", q);
for (int i = 0; i < q; i++)
{
PRINT_OUTPUT(" %3d %3d\n", i, gf.neg[i]);
}
PRINT_OUTPUT("\n\nGF(%d) Square roots\n", q);
for (int i = 0; i < q; i++)
{
PRINT_OUTPUT(" %3d %3d\n", i, gf.root[i]);
}
}
/*
Make ready the Galois Field
*/
int GF_ready(GF & gf, int p, int n, std::vector<int> & xton)
{
size_t q;
std::ostringstream msg;
std::vector<int> poly(n);
gf.n = n;
gf.p = p;
q = 1;
for (int i = 0; i < n; i++)
{
q *= p;
}
gf.q = q;
gf.xton = std::vector<int>(n);
for (size_t i = 0; i < static_cast<size_t>(n); i++)
{
gf.xton[i] = xton[i];
}
gf.plus = bclib::matrix<int>(q,q);
gf.times = bclib::matrix<int>(q,q);
gf.inv = std::vector<int>(q);
gf.neg = std::vector<int>(q);
gf.root = std::vector<int>(q);
gf.poly = bclib::matrix<int>(q, n);
for (size_t i = 0; i < static_cast<size_t>(n); i++)
{
gf.poly(0,i) = 0;
}
for (size_t i = 1; i < q; i++)
{
size_t click;
for (click = 0; gf.poly(i - 1,click) == (p - 1); click++)
{
gf.poly(i,click) = 0;
}
gf.poly(i,click) = gf.poly(i - 1,click) + 1;
for (size_t j = click + 1; j < static_cast<size_t>(n); j++)
{
gf.poly(i,j) = gf.poly(i - 1,j);
}
}
for (size_t i = 0; i < q; i++)
{
for (size_t j = 0; j < q; j++)
{
//GF_poly_sum(p, n, gf.poly[i], gf.poly[j], poly);
GF_poly_sum(p, n, gf.poly.getrow(i), gf.poly.getrow(j), poly);
gf.plus(i,j) = GF_poly2int(p, n, poly);
GF_poly_prod(p, n, xton, gf.poly.getrow(i), gf.poly.getrow(j), poly);
gf.times(i,j) = GF_poly2int(p, n, poly);
}
}
for (size_t i = 0; i < q; i++)
{
gf.inv[i] = -1;
for (size_t j = 0; j < q; j++)
{
if (gf.times(i,j) == 1)
{
gf.inv[i] = j;
}
}
if (i > 0 && gf.inv[i] <= 0)
{
msg << "There is something wrong with the Galois field\n";
msg << "used for q=" << q << ". Element " << i << "has no reciprocal.\n";
throw std::runtime_error(msg.str().c_str());
}
}
for (size_t i = 0; i < q; i++)
{
gf.neg[i] = -1;
for (size_t j = 0; j < q; j++)
if (gf.plus(i,j) == 0)
gf.neg[i] = j;
if (i > 0 && gf.neg[i] <= 0)
{
msg << "There is something wrong with the Galois field\n";
msg << "used for q=" << q << ". Element " << i << " has no negative.\n";
throw std::runtime_error(msg.str().c_str());
}
}
for (size_t i = 0; i < q; i++)
{
gf.root[i] = -1;
for (size_t j = 0; j < q; j++)
{
if (gf.times(j,j) == static_cast<int>(i))
{
gf.root[i] = j;
}
}
}
return 1;
}
GFx::GFx(const GF& generator)
: Z_px(generator.getCharacteristic()), _gfGenerator(generator)
{}
GFx::GFx(const Z& value, const GF& generator)
: Z_px(generator.getCharacteristic()), _gfGenerator(generator) {
this->setIntegerValue(value);
}
int addelkemp(GF & gf, bclib::matrix<int> & A, int ncol)
{
int kay; /* A&K notation */
int square, ksquare, temp;
size_t row, col;
int p = gf.p;
size_t q = gf.q;
std::vector<int> b(q);
std::vector<int> c(q);
std::vector<int> k(q);
// addelkempcheck throws if it fails
addelkempcheck(static_cast<int>(q), p, ncol);
for (size_t i = 0; i < q; i++)
{ /* First q*q rows */
square = gf.times(i,i);
for (size_t j = 0; j < q; j++)
{
row = i * q + j;
col = 0;
if (col < static_cast<size_t>(ncol))
{
A(row, col++) = static_cast<int>(j);
}
for (size_t m = 1; m < q && col < static_cast<size_t>(ncol); m++)
{
A(row,col++) = gf.plus(i,gf.times(m,j));
}
for (size_t m = 0; m < q && col < static_cast<size_t>(ncol); m++)
{
temp = gf.plus(j,gf.times(m,i));
A(row,col++) = gf.plus(temp,square); /* Rgt cols */
}
if (col < static_cast<size_t>(ncol))
{
A(row, col++) = static_cast<int>(i);
}
}
}
if (p != 2) /* Constants kay,b,c,k for odd p */
{
oaaddelkemp::akodd(gf, &kay, b, c, k);
}
else /* Constants kay,b,c,k for even p */
{
oaaddelkemp::akeven(gf, &kay, b, c, k);
}
for (size_t i = 0; i < q; i++)
{ /* Second q*q rows */
square = gf.times(i,i);
ksquare = gf.times(kay,square);
for (size_t j = 0; j < q; j++)
{
row = q * q + i * q + j;
col = 0;
if (col < static_cast<size_t>(ncol))
{
A(row, col++) = static_cast<int>(j);
}
for (size_t m = 1; m < q && col < static_cast<size_t>(ncol); m++, col++)
{
A(row,col) = gf.plus(A(row - q * q,col),b[m]);
}
if (col < static_cast<size_t>(ncol))
{
A(row,col++) = gf.plus(ksquare,j); /* q+1 */
}
for (size_t m = 1; m < q && col < static_cast<size_t>(ncol); m++)
{
temp = gf.times(i,k[m]);
temp = gf.plus(ksquare,temp);
temp = gf.plus(j,temp);
A(row,col++) = gf.plus(temp,c[m]);
}
if (col < static_cast<size_t>(ncol))
{
A(row, col++) = static_cast<int>(i);
}
}
}
return SUCCESS_CHECK;
}
// Lets the compiler synthesize the copy constructor
// GF (const GF<_p>&);
/// Copy constructor
GF(const GF<_p>& s) : _m(s.value()) { assert(_m >= 0); }
inline bool
operator==(const GF<_p>& r, const GF<_p>& s)
{
return r.value() == s.value();
}
inline GF<_p>
operator-(const GF<_p>& r)
{
if (r.value() == 0) return r;
return GF<_p>(_p - r.value()); }
