reduce2()

res2_pair * res2_comp::reduce2 ( res2term *& f, res2term *& fsyz, res2term *& pivot, res2_pair * p )

private

Definition at line 1200 of file res-a0.cpp.

{
  // 'lastterm' is used to append the next monomial to fsyz->syz
  exponents_t REDUCE_exp = ALLOCATE_EXPONENTS(exp_size);
  monomial REDUCE_mon = ALLOCATE_MONOMIAL(monom_size);
 
  res2term *lastterm = (fsyz->next == nullptr ? fsyz : fsyz->next);
  res2term head;
  res2term *red = &head;
  res2_pair *result = nullptr;
  res2_pair *q;
  ring_elem rg;
 
  int count = 0;
  if (M2_gbTrace >= 4) emit_wrapped(",");
 
  while (f != nullptr)
    {
      M->divide(f->monom, f->comp->syz->monom, REDUCE_mon);
      M->to_expvector(REDUCE_mon, REDUCE_exp);
      if (find_ring_divisor(REDUCE_exp, rg))
        {
          // Subtract off f, leave fsyz alone
          Nterm *r = rg;
          M->divide(f->monom, r->monom, REDUCE_mon);
          R->ring_subtract_multiple_to(f, f->coeff, REDUCE_mon, f->comp, rg);
          total_reduce_count++;
          count++;
        }
      else if (find_divisor(f->comp->mi, REDUCE_exp, q))
        {
          if (q->syz_type == SYZ2_S_PAIR || q->syz_type == SYZ2_MAYBE_MINIMAL)
            {
              if (result == nullptr || auto_reduce >= 2)
                {
                  lastterm->next =
                      R->new_term(K->negate(f->coeff), f->monom, q);
                  lastterm = lastterm->next;
                  if (result == nullptr)
                    {
                      // Only do this for the first non-computed pair
                      pivot = lastterm;
                      result = q;
                    }
                  else if (auto_reduce == 2)
                    {
                      // Keep track of this element for later reduction
                      // Store it with q.  Now for a bit of a hack:
                      // We store it in the 'pivot_term' field, since
                      // it cannot have been set yet, and since we don't want
                      // to waste space.
                      auto_reduce_node *au = new auto_reduce_node;
                      au->next =
                          reinterpret_cast<auto_reduce_node *>(q->pivot_term);
                      au->p = pivot->comp;
                      au->pivot = lastterm;
                      q->pivot_term = reinterpret_cast<res2term *>(au);
                    }
                  if (auto_reduce == 0)
                    {
                      // Time to leave: 'red' has nothing in it
                      // with this option, and 'f' is set correctly.
                      return result;
                    }
                }
              red->next = f;
              red = red->next;
              f = f->next;
              continue;
            }
          else
            {
              lastterm->next = R->new_term(K->negate(f->coeff), f->monom, q);
              lastterm = lastterm->next;
              M->divide(f->monom, q->syz->monom, REDUCE_mon);
              R->subtract_multiple_to(f, f->coeff, REDUCE_mon, q->syz);
              total_reduce_count++;
              count++;
            }
        }
      else
        {
          red->next = f;
          red = red->next;
          f = f->next;
        }
    }
  red->next = nullptr;
  f = head.next;
  if (M2_gbTrace >= 4)
    {
      buffer o;
      o << count;
      emit_wrapped(o.str());
    }
  return result;
}

References ALLOCATE_EXPONENTS, ALLOCATE_MONOMIAL, auto_reduce, res2term::coeff, res2term::comp, emit_wrapped(), exp_size, find_divisor(), find_ring_divisor(), K, M, M2_gbTrace, res2_pair::mi, Nterm::monom, res2term::monom, monom_size, monomial, auto_reduce_node::next, res2term::next, auto_reduce_node::p, auto_reduce_node::pivot, res2_pair::pivot_term, R, result(), buffer::str(), res2_pair::syz, SYZ2_MAYBE_MINIMAL, SYZ2_S_PAIR, res2_pair::syz_type, and total_reduce_count.

Referenced by handle_pair().