jade::basic_shunting_yard< TFloat > Class Template Reference

A template for a class that implements the shunting-yard algorithm. The implementation supports '+', '-', '*', and '/' operators; the '(' and ')' parentheses; floating-point numbers; and variables. After parsing an expression, the instance can evaluate the expression if given a table of variable values. More...

#include <jade.shunting_yard.hpp>

Collaboration diagram for jade::basic_shunting_yard< TFloat >:

Public Types
typedef TFloat	float_type
	The floating-point type. More...
typedef std::map< std::string, float_type >	args_type
	A map of strings to floating-point values. The string represent the variable names parsed from the expression passed to the constructor, and the floating-point values are used to evaluate the expression. More...

Public Member Functions
	basic_shunting_yard (std::istream &in)
	Initializes a new instance of the class. The specified input stream provides tokens for the expression. More...
	basic_shunting_yard (const std::string &expression)
	Initializes a new instance of the class. The specified string provides tokens for the expression. More...
const args_type &	get_args () const
	Returns a table of arguments that maps variables to values. The table reference returned has all values set to zero. The table can be used to evaluate the expression. More...
float_type	evaluate (const args_type &args=args_type()) const
	Evaluates the expression using values from the specified table. More...
float_type	operator() (const args_type &args=args_type()) const
	Evaluates the expression using values from the specified table. More...

Detailed Description

template<typename TFloat>
class jade::basic_shunting_yard< TFloat >

A template for a class that implements the shunting-yard algorithm. The implementation supports '+', '-', '*', and '/' operators; the '(' and ')' parentheses; floating-point numbers; and variables. After parsing an expression, the instance can evaluate the expression if given a table of variable values.

Definition at line 22 of file jade.shunting_yard.hpp.

Member Typedef Documentation

args_type

template<typename TFloat >

typedef std::map<std::string, float_type> jade::basic_shunting_yard< TFloat >::args_type

A map of strings to floating-point values. The string represent the variable names parsed from the expression passed to the constructor, and the floating-point values are used to evaluate the expression.

Definition at line 33 of file jade.shunting_yard.hpp.

float_type

template<typename TFloat >

typedef TFloat jade::basic_shunting_yard< TFloat >::float_type

The floating-point type.

Definition at line 25 of file jade.shunting_yard.hpp.

Constructor & Destructor Documentation

basic_shunting_yard() [1/2]

template<typename TFloat >

jade::basic_shunting_yard< TFloat >::basic_shunting_yard ( std::istream &  in )

inlineexplicit

Initializes a new instance of the class. The specified input stream provides tokens for the expression.

Parameters

in	The input stream providing tokens.

Definition at line 40 of file jade.shunting_yard.hpp.

            : _args  ()
            , _queue ()
        {
            std::vector<_token> tokens;
            _scan(in, tokens);
            _enqueue(tokens);
 
            for (const auto & t : _queue)
                if (t.type == _token::variable)
                    _args[t.text] = float_type(0);
 
            evaluate(_args);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

basic_shunting_yard() [2/2]

template<typename TFloat >

jade::basic_shunting_yard< TFloat >::basic_shunting_yard ( const std::string &  expression )

inlineexplicit

Initializes a new instance of the class. The specified string provides tokens for the expression.

Parameters

expression

The string providing tokens.

Definition at line 60 of file jade.shunting_yard.hpp.

            : _args  ()
            , _queue ()
        {
            std::istringstream in (expression);
            *this = basic_shunting_yard(in);
        }

Here is the call graph for this function:

Member Function Documentation

evaluate()

template<typename TFloat >

float_type jade::basic_shunting_yard< TFloat >::evaluate ( const args_type &  args = args_type() ) const

inline

Evaluates the expression using values from the specified table.

Parameters

args	The table of variable values.

Returns

The output from the expression.

Definition at line 84 of file jade.shunting_yard.hpp.

        {
            std::vector<float_type> stack;
 
            for (const auto & t : _queue)
            {
                if (t.type == _token::number)
                {
                    stack.push_back(t.get_value());
                }
                else if (t.type == _token::variable)
                {
                    const auto item = args.find(t.text);
 
                    if (item == args.end())
                        throw jade::error()
                            << "undefined variable '"
                            << t.text
                            << "'";
 
                    stack.push_back(item->second);
                }
                else
                {
                    if (stack.size() < 2)
                        throw jade::error("invalid expression");
 
                    const auto n2 = stack.back();
                    stack.pop_back();
                    const auto n1 = stack.back();
                    stack.pop_back();
 
                    if      (t.type == _token::plus ) stack.push_back(n1 + n2);
                    else if (t.type == _token::minus) stack.push_back(n1 - n2);
                    else if (t.type == _token::star ) stack.push_back(n1 * n2);
                    else if (t.type == _token::slash) stack.push_back(n1 / n2);
                    else throw jade::error("invalid operator");
                }
            }
 
            if (stack.size() != 1)
                throw jade::error("invalid expression");
 
            return stack[0];
        }

Here is the caller graph for this function:

get_args()

template<typename TFloat >

const args_type& jade::basic_shunting_yard< TFloat >::get_args ( ) const

inline

Returns a table of arguments that maps variables to values. The table reference returned has all values set to zero. The table can be used to evaluate the expression.

Returns

A table mapping variables to values.

Definition at line 74 of file jade.shunting_yard.hpp.

        {
            return _args;
        }

operator()()

template<typename TFloat >

float_type jade::basic_shunting_yard< TFloat >::operator() ( const args_type &  args = args_type() ) const

inline

Evaluates the expression using values from the specified table.

Parameters

args	The table of variable values.

Returns

The output from the expression.

Definition at line 135 of file jade.shunting_yard.hpp.

        {
            return evaluate(args);
        }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• jade.shunting_yard.hpp