calc_gb()

enum ComputationStatusCode gb2_comp::calc_gb ( int deg )

virtual

Implements gb_node.

Definition at line 684 of file res-a2-gb.cpp.

{
  enum ComputationStatusCode ret = COMP_DONE;
  if (this_degree > deg) return COMP_DONE;
  if (state == STATE_DONE) return COMP_DONE;  // This includes knowledge
  // that there will be no new generators.
  if (this_degree < deg)
    {
      // Now make sure that previous computations have been done:
      ret = calc_gens(deg - 1);
      if (ret != COMP_DONE) return ret;
    }
  // At this point, we have completely computed a GB with new gens
  // in this degree.  Depending on whether we stopped
  // prematurely, our state will be one of STATE_NEW_DEGREE,
  // STATE_GB, STATE_GENS.
 
  buffer o1;
 
  if (state == STATE_NEW_DEGREE)
    {
      if (use_hilb)
        {
          RingElement *hsyz;
          const PolynomialRing *DR = originalR->get_degree_ring();
          RingElement *h = RingElement::make_raw(DR, DR->zero());
          if (syz != nullptr)
            {
              hsyz = syz->hilbertNumerator();
              if (hsyz == nullptr) return COMP_INTERRUPTED;
              //              o1 << "hsyz = "; hsyz->text_out(o);
              h = (*h) + (*hsyz);
            }
          RingElement *hf1 = hilbertNumerator();
          if (hf1 == nullptr) return COMP_INTERRUPTED;
          h = (*h) + (*hf1);
          RingElement *hF = hilb_comp::hilbertNumerator(F);
          if (hF == nullptr) return COMP_INTERRUPTED;
          h = (*h) - (*hF);
 
#if 0
//        o1 << "\nhf   = "; hf1->text_out(o1);
//        o1 << "\nhF   = "; hF->text_out(o1);
//        o1 << "\nh    = "; h->text_out(o1);
//        o1 << "\n";
//        emit(o1.str());
//        o1.reset();
#endif
          if (M2_gbTrace >= 1 && n_gb_syz != 0)
            {
              buffer o;
              o << "<WARNING: remaining nsyz+ngb = " << n_gb_syz << ">";
              emit(o.str());
            }
 
          n_gb_syz = hilb_comp::coeff_of(h, this_degree);
          if (error()) return COMP_ERROR;
        }
 
      // Compute new s-pairs
      for (int i = n_gb_first; i < n_gb; i++) find_pairs(gb[i]);
 
      state = STATE_GB;
      n_gb_first = n_gb;
      int npairs = get_pairs();
      if (M2_gbTrace >= 1 && npairs > 0)
        {
          buffer o;
          // Should only display this if there are some pairs.
          o << '[' << level << ',' << npairs;
          if (use_hilb) o << ",e" << n_gb_syz;  // << "," << n1 << "," << n2;
          o << ']';
          emit(o.str());
        }
    }
 
  if (state == STATE_GB)
    {
      ret = COMP_COMPUTING;
      // Now compute all the s-pairs here.
      for (;;)
        {
          if (ret != COMP_COMPUTING) break;
          if (system_interrupted())
            {
              ret = COMP_INTERRUPTED;
              break;
            }
          // Check ending conditions...
          if (!s_pair_step())
            {
              ret = COMP_DONE;
              state = STATE_GENS;
            }
        }
    }
 
  if (state == STATE_GENS && orig_syz > 0)
    {
      // Get the generators of the same degree, since these
      // may produce syzygies of this degree.
      ret = gens->calc_gb(deg);
      if (ret == COMP_DONE)
        {
          // Cleanup, go to next degree.
          end_degree();
        }
    }
  // MES: put out an endl if M2_gbTrace >= 1?
 
  // Is this where we should compute the HF again: for use by the
  // previous node... Do we really have to compute it twice per degree/level
  // node?
 
  return ret;
}

References calc_gens(), hilb_comp::coeff_of(), COMP_COMPUTING, COMP_DONE, COMP_ERROR, COMP_INTERRUPTED, emit(), end_degree(), error(), F, find_pairs(), gb(), gens, get_pairs(), hilbertNumerator(), hilb_comp::hilbertNumerator(), level, M2_gbTrace, RingElement::make_raw(), n_gb, n_gb_first, n_gb_syz, orig_syz, originalR, s_pair_step(), state, STATE_DONE, STATE_GB, STATE_GENS, STATE_NEW_DEGREE, buffer::str(), system_interrupted(), syz, this_degree, use_hilb, and Ring::zero().

Referenced by calc_gens().