DGtal: DGtal::MPolynomialGrammar< Iterator

#include <DGtal/io/readers/MPolynomialReader.h>

Inheritance diagram for DGtal::MPolynomialGrammar< Iterator >:

Public Member Functions
	MPolynomialGrammar ()

Data Fields
qi::rule< Iterator, detail::top_node(), ascii::space_type >	top

qi::rule< Iterator, detail::top_node(), ascii::space_type >	mulexpr

qi::rule< Iterator, detail::expr_node(), ascii::space_type >	subexpr

qi::rule< Iterator, detail::top_node(), ascii::space_type >	expexpr

qi::rule< Iterator, detail::monomial_node(), ascii::space_type >	monomial

qi::rule< Iterator, detail::power_node(), ascii::space_type >	variable

qi::rule< Iterator, detail::power_node(), ascii::space_type >	genvariable

qi::rule< Iterator, detail::power_node(), ascii::space_type >	litvariable

Detailed Description

template<typename Iterator>
struct DGtal::MPolynomialGrammar< Iterator >

Defines a grammar for parsing multi-variate polynomials. Based on boost::spirit. You should use a MPolynomialReader to make polynomials from input strings. Another way is to use the overloaded DGtal::operator>>(std::istream &,MPolynomial<n,TRing,TAlloc> &).

Definition at line 148 of file MPolynomialReader.h.

Constructor & Destructor Documentation

◆ MPolynomialGrammar()

template<typename Iterator >

DGtal::MPolynomialGrammar< Iterator >::MPolynomialGrammar ( )

inline

Definition at line 151 of file MPolynomialReader.h.

       : MPolynomialGrammar::base_type(top)
     {
       using qi::eps;
       using qi::lit;
       using qi::int_;
       using qi::_val;
       using qi::_1;
       using qi::double_;
       using phoenix::at_c;
       using phoenix::push_back;
  
       top = // An expression is an additive or subtractive expression
         mulexpr [push_back(at_c<1>(_val), _1)] 
         >> *( ( lit('+') [ push_back(at_c<0>(_val), '+') ] 
                 >> mulexpr [push_back(at_c<1>(_val), _1)]  )
               | ( ( lit('-') [ push_back(at_c<0>(_val), '-') ] 
                     >> mulexpr [push_back(at_c<1>(_val), _1)]  ) ) );
       
       mulexpr = // Each mul expression may be a product of sub-expressions
         subexpr [push_back(at_c<1>(_val), _1)] 
         >> *( ( lit('*') [ push_back(at_c<0>(_val), '*') ]
                 >> mulexpr [push_back(at_c<1>(_val), _1)] ) );
  
       subexpr =  // a sub-expression is a monomial or some ( ) or some ( )^k
         monomial 
         | expexpr;
  
       expexpr = // ( expr ) or ( expr )^k
         lit('(') [ push_back(at_c<0>(_val), '^') ] 
         >> top [ push_back(at_c<1>(_val), _1) ]
         >> lit(')') 
         >> ( ( lit('^') >> int_ [ at_c<2>(_val) = _1 ] )
              | eps [ at_c<2>(_val) = 1 ]  ) ;
         
       monomial =   // coef.power(s)*, or power(s)+
         ( double_ [at_c<0>(_val) = _1] 
           >> *( genvariable [push_back(at_c<1>(_val), _1)] ) )
         | +( genvariable [push_back(at_c<1>(_val), _1)] 
              >> eps [at_c<0>(_val) = 1] );
  
       genvariable = // may be some X_k^m or x^m, y^m ...
         litvariable | variable;
       variable = // X_0 X_1 ... X_0^4 X_1^2 X_3^0 ...
         lit('X') >> lit('_') 
                  >> int_ [at_c<0>(_val) = _1]
                  >> ( ( lit('^') >> int_ [at_c<1>(_val) = _1] ) // X_k^e
                       | eps [at_c<1>(_val) = 1] // X_k
                       );
       litvariable = // x y z t x^4 y^5 z^2 ...
         ( lit('x') [at_c<0>(_val) = 0]
           | lit('y') [at_c<0>(_val) = 1] 
           | lit('z') [at_c<0>(_val) = 2] 
           | lit('t') [at_c<0>(_val) = 3] )
         >> ( ( lit('^') >> int_ [at_c<1>(_val) = _1] ) // x^3 z^4
              | eps [at_c<1>(_val) = 1] // x y z
              );
  
     }