minimalize()

void MonomialTable::minimalize ( int nvars, const VECTOR(exponents_t) & exps, const VECTOR(int) & comps, bool keep_duplicates, VECTOR(int) & result_positions )

staticprivate

Definition at line 297 of file montable.cpp.

{
  /* Step 1: Sort an intarray into ascending order.
     In this order, if e divides f, then e should appear
     before f. Don't actually change 'exp'.  Need a special compare routine.  */
 
  /* Step 2: Make a monomial table. */
 
  /* Step 3: Loop through each element in the intarray.  If the exponent is not
     in the
     monomial ideal, put that index into the result, and insert into the
     monomial ideal.
     If it is in the monomial ideal, go on. */
 
  /* Step alternate3: If ALL minimal elements are to be taken. (e.g. if [1,1,0]
     is
     minimal, but occurs more than once, then keep all occurrences of [1,1,0].
     */
 
  /* Step 4: Remove the monomial table.  Note that the exp vectors should not
     be recreated. */
 
  MonomialTable *T;
 
  VECTOR(int) positions;
  positions.reserve(exps.size());
  for (unsigned int i = 0; i < exps.size(); i++) positions.push_back(i);
 
  /* The following sorts in ascending lex order, considering the component and
     the
     inhomogeneous part of the exponent vector */
  std::stable_sort(
      positions.begin(), positions.end(), sorter(nvars, exps, comps));
 
  T = MonomialTable::make(nvars);
 
  VECTOR(int)::iterator first, end;
  first = positions.begin();
  end = positions.end();
  while (first != end)
    {
      VECTOR(int)::iterator next = first + 1;
      exponents_t this_exp = exps[*first];
      int comp = comps[*first];
      while (next != end)
        {
          if (!exponents_equal(nvars, this_exp, exps[*next])) break;
          if (comp != comps[*next]) break;
          next++;
        }
      if (T->find_divisor(this_exp, comp) == -1)
        {
          /* We have a minimal element */
 
          T->insert(this_exp, comp, *first);
          result_positions.push_back(*first);
          if (keep_duplicates)
            while (++first != next) result_positions.push_back(*first);
        }
 
      first = next;
      /* At this point: [first,next) is the range of equal monomials */
    }
  freemem(T);
}

References end(), exponents_equal(), freemem(), make(), MonomialTable(), T, and VECTOR.