start_computation()

void res2_comp::start_computation ( )

virtual

Implements ResolutionComputation.

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

{
  int n, level;
  res2_pair *p;
 
  if (status() == COMP_DONE) return;
  set_status(COMP_COMPUTING);
 
  if (stop_.length_limit->len > 0)
    {
      if (length_limit < stop_.length_limit->array[0])
        // this also sets length_limit
        increase_level(stop_.length_limit->array[0]);
      else
        length_limit = stop_.length_limit->array[0];
    }
  int compute_level = COMPUTE_RES;
 
  for (level = 1; level <= length_limit + 1; level++) DO(skeleton(level));
 
  if (M2_gbTrace >= 3)
    {
      buffer o;
      o << "--- The total number of pairs in each level/slanted degree -----"
        << newline;
      M2_arrayint a = betti_skeleton();
      betti_display(o, a);
      emit(o.str());
    }
 
  // The skeleton routine sets the following:
  // hidegree: highest slanted degree found so far
  // a flag for each level as to whether the level has new elements
  //    since the last time the pairs were sorted for reduction
 
  if (compute_level <= COMPUTE_SKELETON)
    {
      set_status(COMP_DONE);
      return;
    }
 
  // Set the monomial order for each level, and then prepare for
  // reductions
  for (level = 1; level <= length_limit + 1; level++)
    {
      if (resn[level]->state != RES_MONORDER) continue;
      // The sort will use compare_num's from syz->comp->compare_num
      // and will use these numbers to break ties:
      for (n = 0, p = resn[level]->pairs; p != nullptr; p = p->next, n++)
        p->compare_num = n;
      sort_monorder(resn[level]->pairs);
      for (n = 0, p = resn[level]->pairs; p != nullptr; p = p->next, n++)
        p->compare_num = n;
      sort_reduction(resn[level]->pairs);
      resn[level]->state = RES_REDUCTIONS;
      resn[level]->next_pair = resn[level]->pairs;
    }
 
  for (level = 1; level <= length_limit + 1; level++)
    {
      resn[level]->next_pair = resn[level]->pairs;
    }
 
  // Here: possibly compute the resolution of the monomial ideal first.
 
  if (compute_level <= COMPUTE_MONOMIAL_RES)
    {
      set_status(COMP_DONE);
      return;
    }
 
  if (do_by_level != 0)
    {
      for (level = 1; level <= length_limit; level++)
        DO(do_pairs_by_level(level));
      set_status(COMP_DONE);
      return;
    }
 
  if (do_by_degree)
    {
      for (int deg = 0; deg <= hidegree; deg++)
        {
          if (stop_.stop_after_degree &&
              stop_.degree_limit->array[0] - lodegree < deg)
            //    if (DegreeLimit != NULL && deg > *DegreeLimit - lodegree)
            {
              set_status(COMP_DONE_DEGREE_LIMIT);
              return;
            }
          if (M2_gbTrace >= 1)
            {
              buffer o;
              o << '{' << deg + lodegree << '}';
              emit(o.str());
            }
          for (level = 1; level <= length_limit; level++)
            DO(do_pairs_by_degree(level, deg));
        }
      set_status(COMP_DONE);
      return;
    }
 
  // Now do all of the reductions
  for (int deg = 0; deg <= hidegree; deg++)
    {
      if (stop_.stop_after_degree &&
          stop_.degree_limit->array[0] - lodegree < deg)
        // if (DegreeLimit != NULL && deg > *DegreeLimit - lodegree)
        {
          set_status(COMP_DONE_DEGREE_LIMIT);
          return;
        }
      if (M2_gbTrace >= 1)
        {
          buffer o;
          o << '{' << deg + lodegree << '}';
          emit(o.str());
        }
      for (level = 1; level <= length_limit + 1; level++)
        {
          DO(do_all_pairs(level, deg));
          if (level > projdim) break;
        }
    }
#if 0
//   //This is the older, working version...
//   // Now do all of the reductions
//   for (int deg=0; deg<=hidegree; deg++)
//     {
//       if (DegreeLimit != NULL && deg > *DegreeLimit - lodegree)
//      {
//        set_status(COMP_DONE_DEGREE_LIMIT);
//        return;
//      }
//       if (M2_gbTrace >= 1)
//      {
//        buffer o;
//        o << '{' << deg+lodegree << '}';
//        emit(o.str());
//      }
//       for (level=1; level<=length_limit+1; level++)
//      {
//        DO(do_pairs(level,deg));
//      }
//     }
#endif
  set_status(COMP_DONE);
}

References ResolutionComputation::betti_display(), betti_skeleton(), COMP_COMPUTING, COMP_DONE, COMP_DONE_DEGREE_LIMIT, COMPUTE_MONOMIAL_RES, COMPUTE_RES, COMPUTE_SKELETON, DO, do_all_pairs(), do_by_degree, do_by_level, do_pairs_by_degree(), do_pairs_by_level(), emit(), hidegree, increase_level(), length_limit, lodegree, M2_gbTrace, newline, p, projdim, RES_MONORDER, RES_REDUCTIONS, Computation::set_status(), skeleton(), sort_monorder(), sort_reduction(), state, Computation::status(), Computation::stop_, and buffer::str().