find_weak_generators()

void MonomialTableZZ::find_weak_generators ( int nvars, const VECTOR(mpz_srcptr) & coeffs, const VECTOR(exponents_t) & exps, const VECTOR(int) & comps, VECTOR(int) & result_positions, bool use_stable_sort = true )

static

Definition at line 513 of file montableZZ.cpp.

{
  // Find a set of elements which generate all of them, as a submodule.
  // The indices for these are placed into result_positions.
 
  // The plan for this is simple, although it could be easily optimized.
  // First, sort the elements into increasing order, with coeffs for each
  // specific
  // exponent vector also in increasing order (ASSUMPTION: all coeffs are > 0).
 
  // Second, loop through each one, checking whether it is in the submodule gen
  // by the previous.
  MonomialTableZZ *T = MonomialTableZZ::make(nvars);
 
#if 0
  // debugging
  if (coeffs.size() != exps.size())
    fprintf(stderr, "size mismatch\n");
  if (coeffs.size() != exps.size())
    fprintf(stderr, "size mismatch2\n");
  if (coeffs.size() != comps.size())
    fprintf(stderr, "size mismatch3\n");
#endif
#if 0
  // debugging
  fprintf(stderr, "-------------\n");
  fprintf(stderr, "find_weak_generators %ld\n", coeffs.size());
  for (size_t i = 0; i < coeffs.size(); i++)
    T->show_weak(stderr, coeffs[i], exps[i], comps[i], i);
#endif
 
  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, exp
     vector
     and finally the coefficient */
  if (use_stable_sort)
    std::stable_sort(positions.begin(),
                     positions.end(),
                     montable_sorter_ZZ(nvars, coeffs, exps, comps));
  else
    std::sort(positions.begin(),
              positions.end(),
              montable_sorter_ZZ(nvars, coeffs, exps, comps));
 
#if 0
  // debugging
  fprintf(stderr, "sorted find_weak_generators\n");
  for (size_t i = 0; i < coeffs.size(); i++)
    T->show_weak(stderr, coeffs[i], exps[i], comps[i], positions[i]);
#endif
 
#if 0
//   fprintf(stderr, "sorted terms: ");
//   for (int i=0; i<positions.size(); i++)
//     fprintf(stderr, "%d ", positions[i]);
//   fprintf(stderr, "\n");
#endif
 
  for (VECTOR(int)::iterator j = positions.begin(); j != positions.end(); j++)
    if (!T->is_weak_member(coeffs[*j], exps[*j], comps[*j]))
      {
        result_positions.push_back(*j);
        T->insert(coeffs[*j], exps[*j], comps[*j], *j);
      }
 
#if 0
  // debugging
  fprintf(stderr, "ones we take: find_weak_generators %ld\n", coeffs.size());
  for (size_t i = 0; i < result_positions.size(); i++)
    T->show_weak(stderr, 
                 coeffs[result_positions[i]], 
                 exps[result_positions[i]], 
                 comps[result_positions[i]],
                 result_positions[i]);
  fprintf(stderr, "\n\n");
#endif
  /* We could return T if that is desired */
  //  freemem(T);
}

References make(), T, and VECTOR.

Referenced by gbA::minimalize_pairs_ZZ().