void tableau::resize(int max_wt)
{
if (max_wt <= SCHUR_MAX_WT) return;
deletearray(xloc);
deletearray(yloc);
maxwt = max_wt;
wt = max_wt;
xloc = newarray_atomic(int,maxwt+1);
yloc = newarray_atomic(int,maxwt+1);
}
SchreyerOrder *SchreyerOrder::create(const GBMatrix *m)
{
#ifdef DEVELOPMENT
#warning "the logic in SchreyerOrder creation is WRONG!"
#endif
int i;
const FreeModule *F = m->get_free_module();
const Ring *R = F->get_ring();
const SchreyerOrder *S = F->get_schreyer_order();
const PolynomialRing *P = R->cast_to_PolynomialRing();
const Monoid *M = P->getMonoid();
SchreyerOrder *result = new SchreyerOrder(M);
int rk = INTSIZE(m->elems);
if (rk == 0) return result;
int *base = M->make_one();
int *tiebreaks = newarray_atomic(int,rk);
int *ties = newarray_atomic(int,rk);
for (i=0; i<rk; i++)
{
gbvector *v = m->elems[i];
if (v == NULL || S == NULL)
tiebreaks[i] = i;
else
tiebreaks[i] = i + rk * S->compare_num(v->comp-1);
}
// Now sort tiebreaks in increasing order.
std::sort<int *>(tiebreaks, tiebreaks+rk);
for (i=0; i<rk; i++)
ties[tiebreaks[i] % rk] = i;
for (i=0; i<rk; i++)
{
gbvector *v = m->elems[i];
if (v == NULL)
M->one(base);
else //if (S == NULL)
M->copy(v->monom, base);
#ifdef DEVELOPMENT
#warning "Schreyer unencoded case not handled here"
#endif
#if 0
// else
// M->mult(v->monom, S->base_monom(i), base);
#endif
result->append(ties[i], base);
}
intern_SchreyerOrder(result);
M->remove(base);
deletearray(tiebreaks);
deletearray(ties);
return result;
}
DetComputation::~DetComputation()
{
deletearray(row_set);
deletearray(col_set);
if (D)
{
for (size_t i=0; i<p; i++)
deletearray(D[i]);
deletearray(D);
}
}
binomialGB::monomial_list *binomialGB::ideal_quotient(monomial m) const
{
monomial_list *r;
monomial_list **deglist = newarray(monomial_list *,_max_degree+1);
for (int i=0; i<=_max_degree; i++)
deglist[i] = NULL;
for (iterator p = begin(); p != end(); p++)
{
binomial_gb_elem *g = *p;
gbmin_elem *gm = new gbmin_elem(g, R->mask(g->f.lead));
monomial n = R->quotient(g->f.lead, m);
monomial_list *nl = new monomial_list(n,R->mask(n),gm);
int d = R->degree(n);
nl->next = deglist[d];
deglist[d] = nl;
}
monomial_list *result = NULL;
for (int d=0; d<=_max_degree; d++)
if (deglist[d] != NULL)
{
monomial_list *currentresult = NULL;
while (deglist[d] != NULL)
{
monomial_list *p = deglist[d];
deglist[d] = p->next;
if (find_divisor(result, p->m))
{
R->remove_monomial(p->m);
deleteitem(p->tag); // There is only one element at this point
deleteitem(p);
}
else if ((r = find_divisor(currentresult, p->m)))
{
gbmin_elem *p1 = new gbmin_elem(p->tag->elem, p->mask);
R->remove_monomial(p->m);
deleteitem(p);
p1->next = r->tag;
r->tag = p1;
}
else
{
p->next = currentresult;
currentresult = p;
}
}
if (result == NULL)
result = currentresult;
else if (currentresult != NULL)
{
monomial_list *q;
for (q = result; q->next != NULL; q = q->next);
q->next = currentresult;
}
currentresult = NULL;
}
deletearray(deglist);
return result;
}
void RingZZ::elem_text_out(buffer &o,
const ring_elem ap,
bool p_one,
bool p_plus,
bool p_parens) const
{
mpz_ptr a = ap.get_mpz();
#warning "possible overflow in large int situations"
char s[1000];
char *str;
bool is_neg = (mask_mpz_cmp_si(a, 0) == -1);
bool is_one = (mask_mpz_cmp_si(a, 1) == 0 || mask_mpz_cmp_si(a, -1) == 0);
int size = static_cast<int>(mpz_sizeinbase(a, 10)) + 2;
char *allocstr = (size > 1000 ? newarray_atomic(char,size) : s);
if (!is_neg && p_plus) o << '+';
if (is_one)
{
if (is_neg) o << '-';
if (p_one) o << '1';
}
else
{
str = mpz_get_str(allocstr, 10, a);
o << str;
}
if (size > 1000) deletearray(allocstr);
}
int hilb_comp::coeff_of(const RingElement *h, int deg)
{
// This is a bit of a kludge of a routine. The idea is to loop through
// all the terms of the polynomial h, expand out the exponent, and to add
// up the small integer values of the coefficients of those that have exp[0]=deg.
const PolynomialRing *P = h->get_ring()->cast_to_PolynomialRing();
int *exp = newarray_atomic(int,P->n_vars());
int result = 0;
for (Nterm *f = h->get_value(); f!=NULL; f=f->next)
{
P->getMonoid()->to_expvector(f->monom, exp);
if (exp[0] < deg)
{
ERROR("incorrect Hilbert function given");
#warning "this error message doesn't get printed out, because 0 is a valid return value for this function"
result = 0;
break;
}
else if (exp[0] == deg)
{
int n = P->getCoefficientRing()->coerce_to_int(f->coeff);
result += n;
}
}
deletearray(exp);
return result;
}
void QQ::elem_text_out(buffer &o,
const ring_elem ap,
bool p_one,
bool p_plus,
bool p_parens) const
{
gmp_QQ a = MPQ_VAL(ap);
char s[1000];
char *str;
bool is_neg = (mpq_sgn(a) == -1);
bool is_one = (mask_mpq_cmp_si(a, 1, 1) == 0 || mask_mpq_cmp_si(a, -1, 1) == 0);
int size = static_cast<int>(mpz_sizeinbase (mpq_numref(a), 10)
+ mpz_sizeinbase (mpq_denref(a), 10) + 3);
char *allocstr = (size > 1000 ? newarray_atomic(char,size) : s);
if (!is_neg && p_plus) o << '+';
if (is_one)
{
if (is_neg) o << '-';
if (p_one) o << '1';
}
else
{
str = mpq_get_str(allocstr, 10, a);
o << str;
}
if (size > 1000) deletearray(allocstr);
}
M2_arrayintOrNull FreeModule::select_by_degrees(M2_arrayintOrNull lo, M2_arrayintOrNull hi) const
{
const Ring *R = get_ring();
const Monoid *D = R->degree_monoid();
std::vector<size_t> result;
int ndegrees = D->n_vars();
int *exp = newarray_atomic(int,ndegrees);
for (int i=0; i<rank(); i++)
{
D->to_expvector(degree(i), exp);
#if 0
for (int i=0; i<ndegrees; i++)
printf("%d ", exp[i]);
if (degree_in_box(ndegrees, exp, lo, hi))
printf("yes\n");
else
printf("no\n");
#endif
if (degree_in_box(ndegrees, exp, lo, hi))
result.push_back(i);
}
M2_arrayint selection = stdvector_to_M2_arrayint(result);
deletearray(exp);
return selection;
}
void GBKernelComputation::strip_gb(const GBMatrix *m)
{
const VECTOR(gbvector *) &g = m->elems;
int i;
int *components = newarray_atomic_clear(int, F->rank());
for (i = 0; i < g.size(); i++)
if (g[i] != 0) components[g[i]->comp - 1]++;
for (i = 0; i < g.size(); i++)
{
gbvector head;
gbvector *last = &head;
for (gbvector *v = g[i]; v != 0; v = v->next)
if (components[v->comp - 1] > 0)
{
gbvector *t = GR->gbvector_copy_term(v);
last->next = t;
last = t;
}
last->next = 0;
gb.append(head.next);
}
for (i = 0; i < F->rank(); i++) mi[i] = new MonomialIdeal(R);
deletearray(components);
}
engine_RawRingElementArray rawGetParts(const M2_arrayint wts,
const RingElement *f)
/* Return an array of RingElement's, each having pure weight, and sorted by
strictly increasing weight value. The wt vector values must fit into
a word length integer. */
{
try
{
const PolynomialRing *P = f->get_ring()->cast_to_PolynomialRing();
if (P == 0)
{
ERROR("expected a polynomial");
return 0;
}
long relems_len;
ring_elem *relems = P->get_parts(wts, f->get_value(), relems_len);
engine_RawRingElementArray result =
getmemarraytype(engine_RawRingElementArray, relems_len);
result->len = static_cast<int>(relems_len);
for (int i = 0; i < result->len; i++)
result->array[i] = RingElement::make_raw(P, relems[i]);
deletearray(relems);
return result;
} catch (exc::engine_error e)
{
ERROR(e.what());
return NULL;
}
}
static MonomialIdeal *wrapperFrobbyAlexanderDual(const MonomialIdeal *I,
const M2_arrayint top)
// Assumption: top is an array of at least the number of variables of I
// whose v-th entry is at least as large as the v-th exp of any mingen of I
{
// Create a Frobby Ideal containing I.
int nv = I->topvar() + 1;
if (nv == 0)
{
INTERNAL_ERROR("attempting to use frobby with zero variables");
return 0;
}
mpz_t *topvec = 0;
if (top->len > 0)
{
topvec = newarray(mpz_t, top->len);
for (int i = 0; i < top->len; i++)
mpz_init_set_si(topvec[i], top->array[i]);
}
MonomialIdeal *result = FrobbyAlexanderDual(I, topvec);
// Clean up
if (topvec != 0)
{
for (int i = 0; i < top->len; i++) mpz_clear(topvec[i]);
deletearray(topvec);
}
return result;
}
static MonomialIdeal *FrobbyAlexanderDual(const MonomialIdeal *I,
const mpz_t *topvec)
{
int nv = I->topvar() + 1;
int *exp = newarray_atomic(int, nv);
Frobby::Ideal F(nv);
for (Index<MonomialIdeal> i = I->first(); i.valid(); i++)
{
Bag *b = I->operator[](i);
varpower::to_ntuple(nv, b->monom().raw(), exp);
if (M2_gbTrace >= 4) fprintf(stderr, "adding ");
for (int j = 0; j < nv; j++)
{
if (M2_gbTrace >= 4) fprintf(stderr, "%d ", exp[j]);
F.addExponent(exp[j]);
}
if (M2_gbTrace >= 4) fprintf(stderr, "\n");
}
// Now create the consumer object, and call Frobby
MyIdealConsumer M(I->get_ring(), nv);
Frobby::alexanderDual(F, topvec, M);
deletearray(exp);
// Extract the answer as a MonomialIdeal
return M.result();
}
SchreyerOrder *SchreyerOrder::create(const Matrix *m)
{
int i;
const Ring *R = m->get_ring();
const SchreyerOrder *S = m->rows()->get_schreyer_order();
const PolynomialRing *P = R->cast_to_PolynomialRing();
const Monoid *M = P->getMonoid();
SchreyerOrder *result = new SchreyerOrder(M);
int rk = m->n_cols();
if (rk == 0) return result;
int *base = M->make_one();
int *tiebreaks = newarray_atomic(int,rk);
int *ties = newarray_atomic(int,rk);
for (i=0; i<rk; i++)
{
vec v = (*m)[i];
if (v == NULL || S == NULL)
tiebreaks[i] = i;
else
tiebreaks[i] = i + rk * S->compare_num(v->comp);
}
// Now sort tiebreaks in increasing order.
std::sort<int *>(tiebreaks, tiebreaks+rk);
for (i=0; i<rk; i++)
ties[tiebreaks[i] % rk] = i;
for (i=0; i<rk; i++)
{
vec v = (*m)[i];
if (v == NULL)
M->one(base);
else if (S == NULL)
M->copy(P->lead_flat_monomial(v->coeff), base);
else
{
int x = v->comp;
M->mult(P->lead_flat_monomial(v->coeff), S->base_monom(x), base);
}
result->append(ties[i], base);
}
intern_SchreyerOrder(result);
M->remove(base);
deletearray(tiebreaks);
deletearray(ties);
return result;
}
void BooleanInvolutiveBasis<MonomType>::FillInitialSet(const Matrix* matrix, std::list<Polynom<MonomType>*>& initialSet) const
{
const Monoid* monoid = PRing->getMonoid();
typename MonomType::Integer independ = MonomType::GetDimIndepend();
//construct Polynom for every column in matrix
for (register int column = 0; column < matrix->n_cols(); ++column)
{
vec polynomVector = matrix->elem(column);
if (!polynomVector)
{
continue;
}
Polynom<MonomType>* currentPolynom = new Polynom<MonomType>();
for (Nterm* currentTerm = polynomVector->coeff; currentTerm; currentTerm = currentTerm->next)
{
exponents monomVector = newarray_atomic(int, independ);
monoid->to_expvector(currentTerm->monom, monomVector);
//construct Monom for every term
MonomType* currentMonom = new MonomType();
if (!currentMonom)
{
deletearray(monomVector);
throw std::string("BIBasis::BooleanInvolutiveBasis::FillInitialSet(): got NULL istead of new monom.");
}
for (register typename MonomType::Integer currentVariable = 0; currentVariable < independ; ++currentVariable)
{
if (monomVector[currentVariable])
{
*currentMonom *= currentVariable;
}
}
*currentPolynom += *currentMonom;
deletearray(monomVector);
delete currentMonom;
}
initialSet.push_back(currentPolynom);
}
}
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);
}
void buffer::expand(int newcap)
{
int n = 2 * _capacity;
if (newcap > n) n = newcap;
char *newbuf = newarray_atomic(char,n);
_capacity = n;
memcpy(newbuf, _buf, _size);
deletearray(_buf);
_buf = newbuf;
}
void SMat<CoeffRing>::insert_columns(size_t i, size_t n_to_add)
/* Insert n_to_add columns directly BEFORE column i. */
{
sparsevec **tmp = columns_;
columns_ = 0;
size_t orig_ncols = ncols_;
initialize(nrows_, ncols_ + n_to_add, 0);
for (size_t c = 0; c < i; c++) columns_[c] = tmp[c];
for (size_t c = i; c < orig_ncols; c++) columns_[c + n_to_add] = tmp[c];
deletearray(tmp);
}
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);
}
M2_arrayint gbres_comp::betti_minimal() const
// Negative numbers represent upper bounds
{
int lev, i, d;
int lo = nodes[0]->output_free_module()->lowest_primary_degree();
if (n_nodes >= 2)
{
int lo1 = nodes[1]->output_free_module()->lowest_primary_degree()-1;
if (lo1 < lo) lo=lo1;
}
if (n_nodes >= 3)
{
int lo2 = nodes[2]->output_free_module()->lowest_primary_degree()-2;
if (lo2 < lo) lo=lo2;
}
int hi = lo;
int len = 1;
// Set the hi degree, and len
for (lev=0; lev<n_nodes; lev++)
{
const FreeModule *F = free_module(lev);
if (F->rank() > 0)
len = lev;
for (i=0; i<F->rank(); i++)
{
d = F->primary_degree(i) - lev;
if (d > hi) hi = d;
}
}
int *bettis;
betti_init(lo,hi,len,bettis);
for (lev=0; lev<=len; lev++)
{
const FreeModule *F = free_module(lev);
for (i=0; i<F->rank(); i++)
{
d = F->primary_degree(i) - lev - lo;
bettis[lev+(len+1)*d]++;
}
}
M2_arrayint result = betti_make(lo,hi,len,bettis);
deletearray(bettis);
return result;
}
M2_arrayint RingElement::multi_degree() const
{
if (is_zero())
{
ERROR("the zero element has no degree");
return 0;
}
int *mon = newarray_atomic(int,R->degree_monoid()->monomial_size());
R->degree(get_value(), mon);
M2_arrayint result = R->degree_monoid()->to_arrayint(mon);
deletearray(mon);
return result;
}
void SMat<CoeffRing>::delete_columns(size_t i, size_t j)
/* Delete columns i .. j from M */
{
for (size_t c = i; c <= j; c++) vec_remove(columns_[c]);
sparsevec **tmp = columns_;
columns_ = 0;
size_t ndeleted = j - i + 1;
size_t orig_ncols = ncols_;
initialize(nrows_, ncols_ - (j - i + 1), 0);
for (size_t c = 0; c < i; c++) columns_[c] = tmp[c];
for (size_t c = j + 1; c < orig_ncols; c++) columns_[c - ndeleted] = tmp[c];
deletearray(tmp);
}
void DPoly::increase_size_0(int newdeg, poly &f)
{
assert(f != 0);
if (f->len <= newdeg)
{
long *newelems = newarray_atomic(long,newdeg+1);
long *fp = f->arr.ints;
for (int i=0; i<= f->deg; i++)
newelems[i] = fp[i];
for (int i = f->deg+1; i < newdeg+1; i++)
newelems[i] = 0;
deletearray(fp);
f->arr.ints = newelems;
f->len = newdeg+1;
f->deg = newdeg;
}
void res_comp::new_pairs(res_pair *p)
// Create and insert all of the pairs which will have lead term 'p'.
// This also places 'p' into the appropriate monomial ideal
// Assumption: 'p' lies in a sorted list among its own degree/level
// and only pairs with elements before this in the sorting order
// will be considered.
{
Index<MonomialIdeal> j;
queue<Bag *> elems;
intarray vp; // This is 'p'.
intarray thisvp;
monomial PAIRS_mon = ALLOCATE_MONOMIAL(monom_size);
if (M2_gbTrace >= 10)
{
buffer o;
o << "Computing pairs with first = " << p->me << newline;
emit(o.str());
}
M->divide(p->base_monom, p->first->base_monom, PAIRS_mon);
M->to_varpower(PAIRS_mon, vp);
// First add in syzygies arising from exterior variables
// At the moment, there are none of this sort.
if (P->is_skew_commutative())
{
int *exp = newarray_atomic(int, M->n_vars());
varpower::to_ntuple(M->n_vars(), vp.raw(), exp);
int nskew = P->n_skew_commutative_vars();
for (int v = 0; v < nskew; v++)
{
int w = P->skew_variable(v);
if (exp[w] > 0)
{
thisvp.shrink(0);
varpower::var(w, 1, thisvp);
Bag *b = new Bag(static_cast<void *>(0), thisvp);
elems.insert(b);
}
}
deletearray(exp);
}
const Matrix* BooleanInvolutiveBasis<MonomType>::ToMatrix() const
{
MatrixConstructor matrixConstructor(PRing->make_FreeModule(1), 0);
const Monoid* monoid = PRing->getMonoid();
const ring_elem coefficientUnit = PRing->getCoefficients()->one();
monomial tmpRingMonomial = monoid->make_one();
for (typename std::list<Polynom<MonomType>*>::const_iterator currentPolynom = GBasis.begin();
currentPolynom != GBasis.end();
++currentPolynom)
{
if (!*currentPolynom)
{
continue;
}
ring_elem currentRingPolynomial;
for (const MonomType* currentMonom = &(**currentPolynom).Lm();
currentMonom;
currentMonom = currentMonom->Next)
{
exponents currentExponent = newarray_atomic_clear(int, MonomType::GetDimIndepend());
typename std::set<typename MonomType::Integer> variablesSet = currentMonom->GetVariablesSet();
for (typename std::set<typename MonomType::Integer>::const_iterator currentVariable = variablesSet.begin();
currentVariable != variablesSet.end();
++currentVariable)
{
currentExponent[*currentVariable] = 1;
}
monoid->from_expvector(currentExponent, tmpRingMonomial);
deletearray(currentExponent);
ring_elem tmpRingPolynomial = PRing->make_flat_term(coefficientUnit, tmpRingMonomial);
PRing->add_to(currentRingPolynomial, tmpRingPolynomial);
}
matrixConstructor.append(PRing->make_vec(0, currentRingPolynomial));
}
return matrixConstructor.to_matrix();
}
bool SMat<CoeffRing>::row_permute(size_t start_row, M2_arrayint perm)
{
// We copy one row to another location for each cycle in 'perm' of length > 1.
size_t nrows_to_permute = perm->len;
bool *done = newarray_atomic(bool, nrows_to_permute);
for (size_t i = 0; i < nrows_to_permute; i++) done[i] = true;
for (size_t i = 0; i < nrows_to_permute; i++)
{
size_t j = perm->array[i];
if (!done[j])
{
ERROR("expected permutation");
deletearray(done);
return false;
}
done[j] = false;
}
for (size_t c = 0; c < ncols_; c++) vec_permute(columns_[c], start_row, perm);
return true;
}
void F4GB::show_new_rows_matrix()
{
int ncols = INTSIZE(mat->columns);
int nrows = 0;
for (int nr=0; nr<mat->rows.size(); nr++)
if (is_new_GB_row(nr)) nrows++;
MutableMatrix *gbM = IM2_MutableMatrix_make(KK->get_ring(), nrows, ncols, false);
int r = -1;
for (int nr=0; nr<mat->rows.size(); nr++)
if (is_new_GB_row(nr))
{
r++;
row_elem &row = mat->rows[nr];
ring_elem *rowelems = newarray(ring_elem, row.len);
if (row.coeffs == 0)
{
if (row.monom == 0)
KK->to_ringelem_array(row.len, gens[row.elem]->f.coeffs, rowelems);
else
KK->to_ringelem_array(row.len, gb[row.elem]->f.coeffs, rowelems);
}
else
{
KK->to_ringelem_array(row.len, row.coeffs, rowelems);
}
for (int i=0; i<row.len; i++)
{
int c = row.comps[i];
gbM->set_entry(r,c,rowelems[i]);
}
deletearray(rowelems);
}
buffer o;
gbM->text_out(o);
emit(o.str());
}
void GBKernelComputation::new_pairs(int i)
// Create and insert all of the pairs which will have lead term 'gb[i]'.
// This also places 'in(gb[i])' into the appropriate monomial ideal
{
Index<MonomialIdeal> j;
queue<Bag *> elems;
intarray vp; // This is 'p'.
intarray thisvp;
if (SF)
{
monomial PAIRS_mon = ALLOCATE_MONOMIAL(monom_size);
SF->schreyer_down(gb[i]->monom, gb[i]->comp-1, PAIRS_mon);
M->to_varpower(PAIRS_mon, vp);
}
else
M->to_varpower(gb[i]->monom, vp);
// First add in syzygies arising from exterior variables
// At the moment, there are none of this sort.
if (R->is_skew_commutative())
{
int * find_pairs_exp = newarray_atomic(int, M->n_vars());
varpower::to_ntuple(M->n_vars(), vp.raw(), find_pairs_exp);
for (int w=0; w<R->n_skew_commutative_vars(); w++)
if (find_pairs_exp[R->skew_variable(w)] > 0)
{
thisvp.shrink(0);
varpower::var(w,1,thisvp);
Bag *b = new Bag(static_cast<void *>(0), thisvp);
elems.insert(b);
}
deletearray(find_pairs_exp);
}
FreeModule *FreeModule::exterior(int p) const
// p th exterior power
{
FreeModule *result;
int rk = rank();
if (p == 0)
return get_ring()->make_FreeModule(1);
else
result = new_free();
if (p > rk || p < 0) return result;
int *a = newarray_atomic(int,p);
for (int i=0; i<p; i++)
a[i] = i;
int *deg = degree_monoid()->make_one();
do
{
degree_monoid()->one(deg);
for (int r=0; r<p; r++)
degree_monoid()->mult(deg, degree(a[r]), deg);
result->append(deg);
}
while (comb::increment(p, rk, a));
degree_monoid()->remove(deg);
deletearray(a);
if (schreyer != NULL)
result->schreyer = schreyer->exterior(p);
return result;
}
MonomialHashTable<ValueType>::~MonomialHashTable()
{
deletearray(hashtab);
}
gb_emitter::~gb_emitter()
{
deletearray(these);
}
