eval_term()

ring_elem RingMap::eval_term	(	const Ring *	coeff_ring,
		const ring_elem	coeff,
		const int *	vp,
		int	first_var,
		int	nvars_in_source ) const

Definition at line 140 of file ringmap.cpp.

{
  for (index_varpower i = vp; i.valid(); ++i)
    {
      int v = first_var + i.var();
      if (v >= nvars || _elem[v].is_zero)
        return R->from_long(0);  // The result is zero.
    }
 
  // If K is a coeff ring of R, AND map is an identity on K,
  // then don't recurse: use this value directly.
  // Otherwise, we must recurse, I guess.
  ring_elem result = sourceK->eval(this, a, first_var + nvars_in_source);
  if (R->is_zero(result)) return result;
 
  monomial result_monom = nullptr;
  monomial temp_monom = nullptr;
  ring_elem result_coeff = K->from_long(1);
 
  if (P != nullptr)
    {
      result_monom = M->make_one();
      temp_monom = M->make_one();
    }
 
  if (!R->is_commutative_ring() || R->cast_to_SchurRing())
    {
      // This is the only non-commutative case so far
      for (index_varpower i = vp; i.valid(); ++i)
        {
          int v = first_var + i.var();
          int e = i.exponent();
          ring_elem g;
          if (e >= 0)
            g = _elem[v].bigelem;
          else
            g = R->invert(_elem[v].bigelem);
          for (int j = 0; j < e; j++)
            {
              assert(v < nvars);
              ring_elem tmp = R->mult(g, result);
              R->remove(result);
              result = tmp;
            }
        }
    }
  else
    {
      for (index_varpower i = vp; i.valid(); ++i)
        {
          int v = first_var + i.var();
          int e = i.exponent();
          assert(v < nvars);
          if (_elem[v].bigelem_is_one && e > 0)
            {
              if (!_elem[v].coeff_is_one)
                {
                  ring_elem tmp = K->power(_elem[v].coeff, e);
                  K->mult_to(result_coeff, tmp);
                  K->remove(tmp);
                }
              if (!_elem[v].monom_is_one)
                {
                  M->power(_elem[v].monom, e, temp_monom);
                  M->mult(result_monom, temp_monom, result_monom);
                }
            }
          else
            {
              ring_elem thispart = R->power(_elem[v].bigelem, e);
              R->mult_to(result, thispart);
              R->remove(thispart);
              if (R->is_zero(result)) break;
            }
        }
      if (P != nullptr)
        {
          ring_elem temp = P->make_flat_term(result_coeff, result_monom);
          K->remove(result_coeff);
          M->remove(result_monom);
          M->remove(temp_monom);
          P->mult_to(result, temp);
          P->remove(temp);
        }
      else
        {
          // result_monom has not been used
          // and result, result_coeff are both in the ring K
          result = K->mult(result, result_coeff);
        }
    }
  return result;
}

References _elem, Ring::eval(), K, M, monomial, nvars, P, R, and result().

Referenced by FreeAlgebra::eval(), and PolyRing::eval().