monomials()

Matrix * Matrix::monomials

(

M2_arrayint

vars

)

const

Definition at line 1699 of file matrix.cpp.

{
  const PolynomialRing *P = get_ring()->cast_to_PolynomialRing();
  if (P == nullptr)
    {
      const M2FreeAlgebraOrQuotient* Q = dynamic_cast<const M2FreeAlgebraOrQuotient*>(get_ring());
      if (Q == nullptr)
        {
          ERROR("expected polynomial ring");
          return nullptr;
        }
      ModuleMonomialSet monom_set {ModuleMonomDefaultConfig(Q->n_vars())};
      NCMonomials(monom_set, this);
      //PRINT_ELEMENTS(monom_set.set(), "hashtable: ");
      //PRINT_ELEMENTS(monom_set.uniqueMonoms(), "monoms: ");
      //printHashTableState(monom_set.set());
      //monom_set.display(std::cout);
      return NCMonomialMatrix(monom_set, rows());
      //      NCMonomialSet H(Q->n_vars());
      //      NCMonomials(H, this);
      //      MonomialAreaTest montest;
      //      size_t sz = montest.test1();
      //      std::cout << "sz = " << sz << std::endl;
    }
  const Monoid *M = P->getMonoid();
  const Ring *K = P->getCoefficients();
  int nvars = M->n_vars();
  // Check that 'vars' is valid
  for (unsigned int i = 0; i < vars->len; i++)
    if (vars->array[i] < 0 || vars->array[i] >= nvars)
      {
        ERROR("expected a list of indices of indeterminates");
        return nullptr;
      }
 
  // Now collect all of the monomials
  monomial mon = M->make_one();
  exponents_t exp = newarray_atomic(int, M->n_vars());
  ring_elem one = K->from_long(1);
  exponent_table *E =
      exponent_table_new(50000, vars->len + 1);  // the +1 is for the component
 
  for (int c = 0; c < n_cols(); c++)
    {
      vec v = elem(c);
      for (; v != nullptr; v = v->next)
        {
          for (Nterm& t : v->coeff)
            {
              exponents_t exp1 = newarray_atomic(int, vars->len + 1);
              M->to_expvector(t.monom, exp);
              for (unsigned int i = 0; i < vars->len; i++)
                exp1[i] = exp[vars->array[i]];
              exp1[vars->len] = v->comp;
              exponent_table_put(E, exp1, 1);
            }
        }
    }
 
  // Take all of these monomials and make an array_ out of them
  MatrixConstructor mat(rows(), 0);
  const void **monoms = exponent_table_to_array(E);
  for (int i = 0; i < nvars; i++) exp[i] = 0;
  for (int i = 0; monoms[i] != nullptr; i += 2)
    {
      const_exponents exp1 = reinterpret_cast<const_exponents>(monoms[i]);
      for (unsigned int j = 0; j < vars->len; j++)
        exp[vars->array[j]] = exp1[j];
      int x = exp1[vars->len];  // component
      M->from_expvector(exp, mon);
      ring_elem a = P->make_flat_term(one, mon);
      mat.append(P->make_vec(x, a));
    }
 
  // Remove the garbage memory
  freemem(exp);
  M->remove(mon);
  exponent_table_free(&E);
 
  // Finally, we sort them
  Matrix *result = mat.to_matrix();
  M2_arrayint perm = result->sort(0, -1);
  return result->sub_matrix(perm);
}

References MatrixConstructor::append(), elem(), ERROR, exponent_table_free(), exponent_table_new(), exponent_table_put(), exponent_table_to_array(), freemem(), Monoid::from_expvector(), Ring::from_long(), get_ring(), PolynomialRing::getCoefficients(), PolynomialRing::getMonoid(), PolynomialRing::make_flat_term(), Monoid::make_one(), Ring::make_vec(), Matrix(), MatrixConstructor, Nterm::monom, monomial, monomials(), n_cols(), M2FreeAlgebraOrQuotient::n_vars(), Monoid::n_vars(), NCMonomialMatrix(), NCMonomials(), newarray_atomic, Monoid::remove(), result(), rows(), Monoid::to_expvector(), MatrixConstructor::to_matrix(), and x.

Referenced by IM2_Matrix_monomials(), and monomials().