parseBasicPoly() [1/2]

void parseBasicPoly	(	const std::string_view &	str,
		const IdentifierHash &	idenHash,
		BasicPoly &	result )

This version is a potentially faster alternative when reading many polynomials.

Definition at line 137 of file BasicPolyListParser.cpp.

{
  size_t begin_loc = 0;
  size_t end_loc = str.size();
 
  result.clear();
  
  if (end_loc > begin_loc and str[begin_loc] == '[')
    {
      ++begin_loc;
    }
  while (end_loc > begin_loc and str[end_loc-1] == ' ') --end_loc;
  if (end_loc > begin_loc and str[end_loc-1] == ',') --end_loc;
  if (end_loc > begin_loc and str[end_loc-1] == ':') --end_loc;
  if (end_loc > begin_loc and str[end_loc-1] == ']') --end_loc;
 
  if (begin_loc == end_loc) return; // result is already set to 0.
 
  while (end_loc > begin_loc)
    {
      int sign = 1;
 
      // Read the next term into `result`.
      if (str[begin_loc] == '+')
        {
          ++begin_loc;
        }
      // TODO: do not want +- ...
      if (str[begin_loc] == '-')
        {
          ++begin_loc;
          sign = -1;
        }
      mpz_class coeff{readInteger_mpz_class(str, begin_loc, end_loc)}; // defaults to 1 if no integer present.
 
      if (sign == -1) coeff = -coeff;
      result.mCoefficients.push_back(coeff); // do not clear(coeff) !
 
      // Now we read the monomial part.
      long loc = result.mMonomials.size(); // this is where the length field will go.
      result.mMonomials.push_back(1); // 1 means that the monomial is `1`.
 
      // We expect the first character to be an identifier char.
      // then right after that a `*` or `^'.
      // If we get to "+", or "-" or end of string: we set result.mMonomials[loc] to the correct size.
      while (end_loc > begin_loc)
        {
          char c = str[begin_loc];
          if (c == '-' or c == '+')
            break; // on to the next term
          if (c == '*')
            {
              ++begin_loc;
              if (begin_loc == end_loc)
                {
                  throw parsing_error("line ends after a *");
                  // throw an error
                }
              c = str[begin_loc];
            }
 
          if (not isalpha(c))
            // not well forrmed, I think.
            {
              throw parsing_error("expected an identifier at position " + std::to_string(begin_loc));
            }
          // TODO: in fact, throw an error here
          auto prev_loc = begin_loc;
          int v = readIdentifier(str, idenHash, begin_loc, end_loc);
          if (v == -1)
            {
              throw parsing_error("expected a variable name at position " + std::to_string(prev_loc));
            }
          // TODO: if the identifier is not found, throw an error.
          int e = 1;
          if (end_loc > begin_loc and str[begin_loc] == '^')
            {
              ++begin_loc;
              // if not a digit, throw an error.  Note: here we are currently assuming positive exponents.
              if (begin_loc >= end_loc or not std::isdigit(str[begin_loc]))
                {
                  throw parsing_error("expected a digit at position " + std::to_string(begin_loc));
                }
              e = readInteger_long(str, begin_loc, end_loc);
            }
          // if exponent is zero, don't add anything to monomial.
          if (e != 0)
            {
              result.mMonomials.push_back(v);
              result.mMonomials.push_back(e);
              result.mMonomials[loc] += 2;
            }
        }
    }
}

References readIdentifier(), readInteger_long(), readInteger_mpz_class(), and result().

Referenced by parseBasicPoly(), parseBasicPolyListFromString(), and parseMsolveFromString().