Monoid() [2/2]

Monoid::Monoid ( const MonomialOrdering * mo, const PolynomialRing * DR, const std::vector< std::string > names, const std::vector< int > degs, const std::vector< int > hefts )

private

Definition at line 83 of file monoid.cpp.

    : mDegreeMonoid(deg_ring->getMonoid()),
      mDegreeRing(deg_ring),
      mo_(mo),
      monorder_(nullptr),  // set below
      mVariableCount(rawNumberOfVariables(mo)),
      mVariableNames(names),
      mDegrees(degs),
      mHeftVector(hefts),
      mHeftDegrees({}),   // set below, except in the trivial case.
      exp_size(0),        // set below
      monomial_size_(0),  // set below
      monomial_bound_(0),
      first_weights_slot_(-1),  // set below
      n_invertible_vars_(0),    // set below
      n_before_component_(0),   // set below
      n_after_component_(0),    // set below
      component_up_(true),      // set below
      local_vars({}),           // set below
      overflow(nullptr)
// nslots: set below
{
  monorder_ = monomialOrderMake(mo);
 
  monomial_size_ = monorder_->nslots;
  n_before_component_ = monorder_->nslots_before_component;
  n_after_component_ = monomial_size_ - n_before_component_;
  component_up_ = monorder_->component_up;
 
  // Set nslots_
  int total = 0;
  for (int i = 0; i < monorder_->nblocks; i++)
    {
      total += monorder_->blocks[i].nslots;
      nslots_.push_back(total);
    }
 
  // Set first_weight_value_
  bool get_out = false;
  first_weights_slot_ = -1;
  for (int i = 0; i < monorder_->nblocks && !get_out; i++)
    {
      switch (monorder_->blocks[i].typ)
        {
          case MO_LEX:
          case MO_LEX2:
          case MO_LEX4:
          case MO_NC_LEX:
            get_out = true;
            break;
          case MO_REVLEX:
          case MO_LAURENT:
          case MO_LAURENT_REVLEX:
          case MO_GREVLEX:
          case MO_GREVLEX2:
          case MO_GREVLEX4:
          case MO_GREVLEX_WTS:
          case MO_GREVLEX2_WTS:
          case MO_GREVLEX4_WTS:
          case MO_WEIGHTS:
            first_weights_slot_ = 0;
          case MO_POSITION_UP:
            continue;
          case MO_POSITION_DOWN:
            continue;
          default:
            INTERNAL_ERROR("monomial order block type not handled");
        }
    }
  exp_size = EXPONENT_BYTE_SIZE(mVariableCount);
 
  n_invertible_vars_ = rawNumberOfInvertibleVariables(mo_);
 
  set_degrees();
  set_overflow_flags();
 
  local_vars = M2_arrayint_to_stdvector<int>(rawNonTermOrderVariables(mo));
 
  for (int i=0; i<n_vars(); ++i)
    {
      bool isLaurent = isLaurentVariable(i);
      mLaurentVariablesPredicate.push_back(isLaurent);
    }
 
  // Debugging only:
  //  fprintf(stderr, "%d variables < 1\n", local_vars->len);
  //  if (local_vars->len > 0)
  //    {
  //      fprintf(stderr, "they are: ");
  //      for (int i=0; i<local_vars->len; i++)
  //      fprintf(stderr, "%d ", local_vars->array[i]);
  //      fprintf(stderr, "\n");
  //    }
}

References mDegreeMonoid, mDegreeRing, mDegrees, mHeftDegrees, mHeftVector, mo_, monorder_, mVariableCount, mVariableNames, and rawNumberOfVariables().