void F4GB::insert_gb_element(row_elem &r)
{
// Insert row as gb element.
// Actions to do:
// translate row to a gbelem + poly
// set degrees as needed
// insert the monomial into the lookup table
// find new pairs associated to this new element
int nslots = M->max_monomial_size();
int nlongs = r.len * nslots;
gbelem *result = new gbelem;
result->f.len = r.len;
// If the coeff array is null, then that means the coeffs come from the original array
// Here we copy it over.
result->f.coeffs = (r.coeffs ? r.coeffs : KK->copy_F4CoefficientArray(r.len, get_coeffs_array(r)));
r.coeffs = 0;;
result->f.monoms = Mem->allocate_monomial_array(nlongs);
monomial_word *nextmonom = result->f.monoms;
for (int i=0; i<r.len; i++)
{
M->copy(mat->columns[r.comps[i]].monom, nextmonom);
nextmonom += nslots;
}
Mem->components.deallocate(r.comps);
r.len = 0;
result->deg = this_degree;
result->alpha = static_cast<int>(M->last_exponent(result->f.monoms));
result->minlevel = ELEM_MIN_GB; // MES: How do
// we distinguish between ELEM_MIN_GB, ELEM_POSSIBLE_MINGEN?
int which = INTSIZE(gb);
gb.push_back(result);
if (hilbert)
{
int x;
int *exp = newarray_atomic(int, M->n_vars());
M->to_intstar_vector(result->f.monoms, exp, x);
hilbert->addMonomial(exp, x+1);
deletearray(exp);
}
// now insert the lead monomial into the lookup table
varpower_monomial vp = newarray_atomic(varpower_word, 2 * M->n_vars() + 1);
M->to_varpower_monomial(result->f.monoms, vp);
lookup->insert_minimal_vp(M->get_component(result->f.monoms), vp, which);
deleteitem(vp);
// now go forth and find those new pairs
S->find_new_pairs(is_ideal);
}
MonomialInfo::MonomialInfo(int nvars0, const MonomialOrdering *mo)
{
nvars = nvars0;
hashfcn = newarray_atomic(monomial_word,nvars);
for (int i=0; i<nvars; i++)
hashfcn[i] = rand();
mask = 0x10000000;
ncalls_compare = 0;
ncalls_mult = 0;
ncalls_get_component = 0;
ncalls_from_exponent_vector = 0;
ncalls_to_exponent_vector = 0;
ncalls_to_varpower = 0;
ncalls_from_varpower = 0;
ncalls_is_equal = 0;
ncalls_is_equal_true = 0;
ncalls_divide = 0;
ncalls_weight = 0;
ncalls_unneccesary = 0;
ncalls_quotient_as_vp = 0;
nweights = 0;
weight_vectors = 0;
if (moIsLex(mo))
{
compare = &MonomialInfo::compare_lex;
if (M2_gbTrace >= 1)
fprintf(stderr, "lex order\n");
}
else if (moIsGRevLex(mo))
{
compare = &MonomialInfo::compare_grevlex;
if (M2_gbTrace >= 1)
fprintf(stderr, "grevlex order\n");
}
else
{
weight_vectors = moGetWeightValues(mo);
nweights = weight_vectors->len / nvars;
compare = &MonomialInfo::compare_weightvector;
if (M2_gbTrace >= 1)
fprintf(stderr, "weight order\n");
}
nslots = 2 + nvars + nweights;
firstvar = 2 + nweights;
}
void SMat<CoeffRing>::vec_permute(sparsevec *&v, size_t start_row, M2_arrayint perm) const
{
size_t *perminv = newarray_atomic(size_t,perm->len);
for (size_t i=0; i<perm->len; i++)
perminv[perm->array[i]] = i;
size_t end_row = start_row + perm->len;
for (sparsevec *w = v; w != 0; w = w->next)
if (w->row >= start_row && w->row < end_row)
w->row = start_row + perminv[w->row - start_row];
vec_sort(v);
deletearray(perminv);
}
DetComputation::DetComputation(const Matrix *M0, int p0,
bool do_exterior0,
int strategy0)
: R(M0->get_ring()),
M(M0),
done(false),
p(p0),
do_exterior(do_exterior0),
strategy(strategy0),
row_set(NULL),
col_set(NULL),
this_row(0),
this_col(0),
D(0)
{
if (do_exterior)
{
F = M->rows()->exterior(p);
FreeModule *G = M->cols()->exterior(p);
int *deg = R->degree_monoid()->make_new(M->degree_shift());
R->degree_monoid()->power(deg, p, deg);
result = MatrixConstructor(F,G,deg);
R->degree_monoid()->remove(deg);
}
else
{
F = R->make_FreeModule(1);
result = MatrixConstructor(F,0);
}
// Handle trivial cases
if (p < 0)
{
// In either case, want a zero matrix
done = true;
return;
}
if (p == 0)
{
// We want a single element which is '1'
if (do_exterior)
result.set_entry(0,0,R->one());
else
result.append(R->make_vec(0,R->one()));
done = true;
return;
}
if (p > M->n_rows() || p > M->n_cols())
{
// Zero matrix in either case
done = true;
return;
}
done = false;
row_set = newarray_atomic(size_t,p);
col_set = newarray_atomic(size_t,p);
for (size_t i=0; i<p; i++)
{
row_set[i] = i;
col_set[i] = i;
}
D = newarray(ring_elem *,p);
for (size_t i=0; i<p; i++)
{
D[i] = newarray(ring_elem,p);
for (size_t j=0; j<p;j++) D[i][j] = ZERO_RINGELEM;
}
}
GaloisFieldTable::GaloisFieldTable(const PolynomialRing& R,
const ring_elem prim):
mCharac(static_cast<int>(R.characteristic())),
mOriginalRing(R),
mPrimitiveElement(prim)
{
M2_ASSERT(mOriginalRing.n_quotients() == 1);
mGenerator = RingElement::make_raw(&R, R.copy(prim));
ring_elem f = mOriginalRing.quotient_element(0);
Nterm *t = f;
mDimension = mOriginalRing.getMonoid()->primary_degree(t->monom);
mOrder = mCharac;
for (int i=1; i<mDimension; i++) mOrder *= mCharac;
mOne = mOrder - 1; // representation for the number 1: p^n - 1.
mOrderMinusOne = mOne; // p^n - 1
mMinusOne = (mCharac == 2 ? mOne : mOne/2);
// Get ready to create mOneTable.
std::vector<ring_elem> polys;
polys.push_back(mOriginalRing.from_long(0));
polys.push_back(mOriginalRing.copy(mPrimitiveElement));
ring_elem oneR = mOriginalRing.from_long(1);
mGeneratorExponent = static_cast<GFElement>(-1);
ring_elem x = mOriginalRing.var(0);
if (mOriginalRing.is_equal(mPrimitiveElement, x))
mGeneratorExponent = 1;
for (GFElement i=2; i<=mOne; i++)
{
ring_elem g = mOriginalRing.mult(polys[i-1], mPrimitiveElement);
polys.push_back(g);
if (mOriginalRing.is_equal(g, oneR)) break;
if (mOriginalRing.is_equal(g, x))
mGeneratorExponent = i;
}
#if 0
for (size_t i = 0; i < polys.size(); i++)
{
std::cerr << i << " ";
dringelem(&R, polys[i]);
std::cerr << "\n";
}
#endif
M2_ASSERT(polys.size() == mOrder);
M2_ASSERT(mGeneratorExponent != static_cast<GFElement>(-1));
// Set 'one_table'.
mOneTable = newarray_atomic(GFElement,mOrder);
mOneTable[0] = mOrderMinusOne;
for (GFElement i=1; i<=mOrderMinusOne; i++)
{
if (system_interrupted())
{
// first clean up?
return;
}
ring_elem f1 = mOriginalRing.add(polys[i], oneR);
GFElement j;
for (j=0; j<=mOrderMinusOne; j++)
if (mOriginalRing.is_equal(f1, polys[j]))
break;
if (j > mOrderMinusOne)
{
std::cout << "oops: didn't find element " << i << " !!" << std::endl;
}
mOneTable[i] = j;
}
// Create the ZZ/P ---> GF(Q) inclusion map
mFromIntTable = newarray_atomic(GFElement,mCharac);
GFElement a = mOne;;
mFromIntTable[0] = 0;
for (GFElement i=1; i<mCharac; i++)
{
mFromIntTable[i] = a;
a = mOneTable[a];
}
}
