do_computation()

void gbA::do_computation ( )

private

Definition at line 2398 of file gb-default.cpp.

{
  ComputationStatusCode ret;
  spair *p;
 
  // initial state is STATE_NEWDEGREE
 
  if (stop_.always_stop) return;  // don't change status
 
  if ((ret = computation_is_complete()) != COMP_COMPUTING)
    {
      set_status(ret);
      return;
    }
 
  if (M2_gbTrace == 15)
    {
      emit_line("[gb]");
    }
  else if (M2_gbTrace >= 1)
    {
      emit_wrapped("[gb]");
    }
  for (;;)
    {
      if (stop_.stop_after_degree && this_degree > stop_.degree_limit->array[0])
        {
          // Break out now if we don't have anything else to compute in this
          // degree.
          set_status(COMP_DONE_DEGREE_LIMIT);
          return;
        }
      if (M2_gbTrace & PrintingDegree)
        {
        }
 
      switch (state)
        {
          case STATE_NEWPAIRS:
            // Loop through all of the new GB elements, and
            // compute spairs.  Start at np_i
            // np_i is initialized at the beginning, and also here.
            while (np_i < n_gb)
              {
                if (system_interrupted())
                  {
                    set_status(COMP_INTERRUPTED);
                    return;
                  }
                if (gb[np_i])
                  {
                    if (gb[np_i]->minlevel & ELEM_MINGB) update_pairs(np_i);
                  }
                np_i++;
              }
            state = STATE_HILB;
            [[fallthrough]];
 
          case STATE_HILB:
            // If we are using hilbert function tracking:
            // Recompute the Hilbert function if new GB elements have been added
 
            if (hilb_new_elems)
              {
                // Recompute h, hf_diff
                Matrix *hf = make_lead_term_matrix();
                RingElement *h = hilb_comp::hilbertNumerator(hf);
                if (h == nullptr)
                  {
                    set_status(COMP_INTERRUPTED);
                    return;
                  }
                hf_diff = (*h) - (*hf_orig);
                hilb_new_elems = false;
              }
            state = STATE_NEWDEGREE;
            [[fallthrough]];
 
          case STATE_NEWDEGREE:
            // Get the spairs and generators for the next degree
 
            if (S->n_in_degree == 0)
              {
                // int old_degree = this_degree;
                npairs = spair_set_prepare_next_degree(
                    this_degree);  // sets this_degree
                //                if (old_degree < this_degree)
                //                  first_in_degree = INTSIZE(gb);
                complete_thru_this_degree = this_degree - 1;
                if (npairs == 0)
                  {
                    state = STATE_DONE;
                    set_status(COMP_DONE);
                    return;
                  }
                if (stop_.stop_after_degree &&
                    this_degree > stop_.degree_limit->array[0])
                  {
                    set_status(COMP_DONE_DEGREE_LIMIT);
                    return;
                  }
                if (use_hilb)
                  {
                    hilb_n_in_degree =
                        hilb_comp::coeff_of(hf_diff, this_degree);
                    if (error())
                      {
                        // The previous line can give an error, which means that
                        // the Hilbert
                        // function declared was actually incorrect.
                        set_status(COMP_ERROR);
                        return;
                      }
                    if (hilb_n_in_degree == 0) flush_pairs();
                  }
              }
            if (M2_gbTrace == 15)
              {
                buffer o;
                o << "DEGREE " << this_degree;
                o << ", number of spairs = " << npairs;
                if (use_hilb)
                  o << ", expected number in this degree = "
                    << hilb_n_in_degree;
                emit_line(o.str());
              }
            else if (M2_gbTrace >= 1)
              {
                buffer o;
                o << '{' << this_degree << '}';
                o << '(';
                if (use_hilb) o << hilb_n_in_degree << ',';
                o << npairs << ')';
                emit_wrapped(o.str());
              }
            ar_i = n_gb;
            ar_j = ar_i + 1;
            state = STATE_SPAIRS;
 
          case STATE_SPAIRS:
          case STATE_GENS:
            // Compute the spairs for this degree
            while ((p = spair_set_next()) != nullptr)
              {
                process_spair(p);
                npairs--;
                n_pairs_computed++;
 
                if ((ret = computation_is_complete()) != COMP_COMPUTING)
                  {
                    set_status(ret);
                    return;
                  }
 
                if (system_interrupted())
                  {
                    set_status(COMP_INTERRUPTED);
                    return;
                  }
              }
            state = STATE_AUTOREDUCE;
            [[fallthrough]];
          // or state = STATE_NEWPAIRS
 
          case STATE_AUTOREDUCE:
            // This is still possibly best performed when inserting a new
            // element
            // Perform the necessary or desired auto-reductions
            if (!is_local_gb)
              while (ar_i < n_gb)
                {
                  if (gb[ar_i])
                    while (ar_j < n_gb)
                      {
                        if (system_interrupted())
                          {
                            set_status(COMP_INTERRUPTED);
                            return;
                          }
                        if (gb[ar_j])
                          {
                            if (over_ZZ())
                              {
                                R->gbvector_auto_reduce_ZZ(_F,
                                                           _Fsyz,
                                                           gb[ar_i]->g.f,
                                                           gb[ar_i]->g.fsyz,
                                                           gb[ar_j]->g.f,
                                                           gb[ar_j]->g.fsyz);
                              }
                            else
                              {
                                R->gbvector_auto_reduce(_F,
                                                        _Fsyz,
                                                        gb[ar_i]->g.f,
                                                        gb[ar_i]->g.fsyz,
                                                        gb[ar_j]->g.f,
                                                        gb[ar_j]->g.fsyz);
                              }
                          }
                        ar_j++;
                      }
                  ar_i++;
                  ar_j = ar_i + 1;
                }
            state = STATE_NEWPAIRS;
            break;
 
          case STATE_DONE:
            return;
        }
    }
}

References _F, _Fsyz, ar_i, ar_j, hilb_comp::coeff_of(), COMP_COMPUTING, COMP_DONE, COMP_DONE_DEGREE_LIMIT, COMP_ERROR, COMP_INTERRUPTED, complete_thru_this_degree, computation_is_complete(), ELEM_MINGB, emit_line(), emit_wrapped(), error(), flush_pairs(), gb(), hf_diff, hilb_n_in_degree, hilb_new_elems, hilb_comp::hilbertNumerator(), is_local_gb, M2_gbTrace, make_lead_term_matrix(), Matrix, n_gb, n_pairs_computed, np_i, npairs, over_ZZ(), p, PrintingDegree, process_spair(), R, S, Computation::set_status(), spair_set_next(), spair_set_prepare_next_degree(), state, STATE_AUTOREDUCE, STATE_DONE, STATE_GENS, STATE_HILB, STATE_NEWDEGREE, STATE_NEWPAIRS, STATE_SPAIRS, Computation::stop_, buffer::str(), system_interrupted(), this_degree, update_pairs(), and use_hilb.

Referenced by start_computation().