start_computation()

enum ComputationStatusCode F4GB::start_computation

(

StopConditions &

stop_

)

Definition at line 1130 of file f4.cpp.

{
  clock_sort_columns = 0;
  clock_gauss = 0;
  clock_make_matrix = 0;
  int npairs = 0;
 
  //  test_spair_code();
 
  enum ComputationStatusCode is_done = COMP_COMPUTING;
 
  for (;;)
    {
      if (system_interrupted())
        {
          is_done = COMP_INTERRUPTED;
          break;
        }
 
      is_done = computation_is_complete(stop_);
      if (is_done != COMP_COMPUTING) break;
 
      //this_degree = mSPairSet.prepare_next_degree(-1, npairs);
      auto thisDegInfo = mSPairSet.setThisDegree();
      
      if (not thisDegInfo.first)
        {
          is_done = COMP_DONE;
          break;
        }
 
      this_degree = thisDegInfo.second;
      
      if (stop_.stop_after_degree && this_degree > stop_.degree_limit->array[0])
        {
          is_done = COMP_DONE_DEGREE_LIMIT;
          break;
        }
 
      if (hilbert)
        {
          if (!hilbert->setDegree(this_degree))
            {
              if (error())
                is_done = COMP_ERROR;
              else
                is_done = COMP_INTERRUPTED;
              break;
            }
        }
 
      if (M2_gbTrace >= 1)
        {
          if (hilbert)
            fprintf(stderr,
                    "DEGREE %d (nexpected %d npairs %d)\n",
                    this_degree,
                    hilbert->nRemainingExpected(),
                    npairs);
          else
            fprintf(stderr, "DEGREE %d (npairs %d)\n", this_degree, npairs);
        }
      do_spairs();
      complete_thru_this_degree = this_degree;
    }
 
  if (M2_gbTrace >= 2)
    {
      // fprintf(stderr,
      //         "number of calls to cancel row       : %ld\n",
      //         mGausser->n_dense_row_cancel);
      // fprintf(stderr,
      //         "number of calls to subtract_multiple: %ld\n",
      //         mGausser->n_subtract_multiple);
      fprintf(
          stderr, "total time for sorting columns: %f\n", clock_sort_columns);
      fprintf(stderr,
              "total time for making matrix (includes sort): %f\n",
              ((double)clock_make_matrix) / CLOCKS_PER_SEC);
      fprintf(stderr,
              "total time for gauss: %f\n",
              ((double)clock_gauss) / CLOCKS_PER_SEC);
      fprintf(stderr,
              "parallel tbb time for gauss: %g\n",
              mParallelGaussTime);
      fprintf(stderr,
              "serial tbb time for gauss: %g\n",
              mSerialGaussTime);
      fprintf(stderr,
              "total time for finding new spairs: %g\n",
              mNewSPairTime);
      fprintf(stderr,
              "total time for creating pre spairs: %g\n",
              mSPairSet.secondsToCreatePrePairs());
      fprintf(stderr,
              "total time for minimizing new spairs: %g\n",
              mSPairSet.secondsToMinimizePairs());
      fprintf(stderr,
              "total time for inserting new gb elements: %g\n",
              mInsertGBTime);
      fprintf(stderr,
              "number of spairs computed           : %ld\n",
              n_pairs_computed);
      fprintf(stderr,
              "number of reduction steps           : %ld\n",
              n_reduction_steps);
      if (M2_gbTrace >= 3)
      {
        fprintf(stderr,
              "number of spairs removed by criterion = %ld\n",
              mSPairSet.n_unneeded_pairs());
        mMonomialInfo->show();
      }
    }
 
  return is_done;
}

References clock_gauss, clock_make_matrix, clock_sort_columns, COMP_COMPUTING, COMP_DONE, COMP_DONE_DEGREE_LIMIT, COMP_ERROR, COMP_INTERRUPTED, complete_thru_this_degree, computation_is_complete(), StopConditions::degree_limit, do_spairs(), error(), hilbert, M2_gbTrace, mInsertGBTime, mMonomialInfo, mNewSPairTime, mParallelGaussTime, mSerialGaussTime, mSPairSet, n_pairs_computed, n_reduction_steps, StopConditions::stop_after_degree, system_interrupted(), and this_degree.