initialize()

void res2_comp::initialize ( const Matrix * mat, int LengthLimit, bool UseDegreeLimit, int SlantedDegreeLimit, int SortStrategy )

private

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

{
  set_status(COMP_COMPUTING);
  P = mat->get_ring()->cast_to_PolynomialRing();
  assert(P != NULL);
  R = new res2_poly(const_cast<PolynomialRing *>(P));
  M = P->getMonoid();
  K = P->getCoefficientRing();
  generator_matrix = mat;
 
  exp_size = EXPONENT_BYTE_SIZE(P->n_vars());
  monom_size = MONOMIAL_BYTE_SIZE(M->monomial_size());
 
  res2_pair_stash = new stash("res2pair", sizeof(res2_pair));
  mi_stash = new stash("res2 minodes", sizeof(Nmi_node));
 
  length_limit = -3;  // The resolution is always kept at least in range
                      // 0 .. length_limit + 2.
  increase_level(LengthLimit);
 
  projdim = 0;
  max_mon_degree = M->max_degree();
 
  if (mat->n_rows() > 0)
    {
      lodegree = mat->rows()->primary_degree(0);
      for (auto i = 1; i < mat->n_rows(); i++)
        if (lodegree > mat->rows()->primary_degree(i))
          lodegree = mat->rows()->primary_degree(i);
    }
  else
    lodegree = 0;
 
  // This can't actually set lodegree, can it?
  for (auto i = 0; i < mat->n_cols(); i++)
    if (lodegree > mat->cols()->primary_degree(i) - 1)
      lodegree = mat->cols()->primary_degree(i) - 1;
 
  hidegree = 0;  // hidegree is an offset from 'lodegree'.
 
  have_degree_limit = UseDegreeLimit;
  hard_degree_limit = SlantedDegreeLimit;
 
  nleft = 0;
  npairs = 0;
  nminimal = 0;
  total_reduce_count = 0;
 
  n_ones = 0;
  n_unique = 0;
  n_others = 0;
 
  // Do level 0
  next_component = 0;
  for (auto i = 0; i < mat->n_rows(); i++)
    {
      res2_pair *p = new_base_res2_pair(i);
      base_components.push_back(p);
    }
  for (auto p = base_components.rbegin(); p != base_components.rend(); ++p)
    insert_pair(*p);
 
  // Do level 1
  for (auto i = 0; i < generator_matrix->n_cols(); i++)
    if ((*generator_matrix)[i] != nullptr)
      {
        res2_pair *p = new_res2_pair(i);  // Makes a generator 'pair'
        insert_pair(p);
      }
 
  // Set variables for compare_res2_pairs
  compare_type = COMPARE_LEX;
  compare_use_degree = 0;
  compare_use_descending = 1;
  compare_use_reverse = 0;
 
  skeleton_sort = SortStrategy & 63;
  reduction_sort = (SortStrategy >> 6) & 63;
  reduction_sort |= FLAGS_DEGREE;  // ALWAYS do by increasing degree.
  do_by_level = (unsigned char)(SortStrategy & FLAGS_LEVEL ? 1 : 0);
  if (SortStrategy & FLAGS_LEVEL_STRIP) do_by_level = 2;
  do_by_degree = (unsigned char)(SortStrategy & FLAGS_DEGREELEVEL ? 1 : 0);
  auto_reduce = (SortStrategy & FLAGS_AUTO) >> SHIFT_AUTO;
  use_respolyHeaps = (unsigned char)(SortStrategy & FLAGS_GEO ? 1 : 0);
 
  if (do_by_degree) do_by_level = 0;
  if (M2_gbTrace >= 3)
    {
      buffer o;
      o << "auto-reduce level = " << auto_reduce << newline;
      if (do_by_level)
        {
          o << "computing resolution level by level" << newline;
          if (do_by_level == 2) o << "with strip optimization" << newline;
        }
      if (do_by_degree)
        o << "computing resolution degree by slanted degree" << newline;
      if (use_respolyHeaps) o << "using heap based reduction" << newline;
      o << "skeleton order = ";
      display_order(o, skeleton_sort);
      o << "reduction sort = ";
      display_order(o, reduction_sort);
      emit(o.str());
    }
}

References auto_reduce, Ring::cast_to_PolynomialRing(), Matrix::cols(), COMP_COMPUTING, COMPARE_LEX, compare_type, compare_use_degree, compare_use_descending, compare_use_reverse, display_order(), do_by_degree, do_by_level, emit(), exp_size, EXPONENT_BYTE_SIZE, FLAGS_AUTO, FLAGS_DEGREE, FLAGS_DEGREELEVEL, FLAGS_GEO, FLAGS_LEVEL, FLAGS_LEVEL_STRIP, generator_matrix, Matrix::get_ring(), hard_degree_limit, have_degree_limit, hidegree, increase_level(), insert_pair(), K, length_limit, lodegree, M, M2_gbTrace, Matrix, max_mon_degree, mi_stash, monom_size, MONOMIAL_BYTE_SIZE, Matrix::n_cols(), n_ones, n_others, Matrix::n_rows(), n_unique, new_base_res2_pair(), new_res2_pair(), newline, next_component, nleft, nminimal, npairs, P, p, FreeModule::primary_degree(), projdim, R, reduction_sort, res2_pair_stash, Matrix::rows(), Computation::set_status(), SHIFT_AUTO, skeleton_sort, buffer::str(), total_reduce_count, and use_respolyHeaps.

Referenced by res2_comp().