gum::Formula Class Reference

Evaluates a string as a algebraic formula. More...

#include <formula.h>

Collaboration diagram for gum::Formula:

Public Member Functions
	Formula (const std::string &f)
	Class constructor. More...
	Formula (const Formula &source)
	Copy constructor. More...
	Formula (Formula &&source)
	Move constructor. More...
	~Formula ()
	Class destructor. More...
Constructors and destructor
	Formula (short s)
	Constructor. More...
	Formula (unsigned short us)
	Constructor. More...
	Formula (int i)
	Constructor. More...
	Formula (unsigned int ui)
	Constructor. More...
	Formula (long l)
	Constructor. More...
	Formula (unsigned long ul)
	Constructor. More...
	Formula (long long l)
	Constructor. More...
	Formula (unsigned long long ul)
	Constructor. More...
	Formula (float f)
	Constructor. More...
	Formula (double d)
	Constructor. More...
Operators
Formula &	operator= (const Formula &source)
	Copy operator. More...
Formula &	operator= (Formula &&source)
	Move operator. More...
	operator double () const
	Allows implicit conversion to doubles. More...
Accessors & modifiers
HashTable< std::string, double > &	variables ()
	Returns the variables used by this gum::Formula. More...
const HashTable< std::string, double > &	variables () const
	Returns the variables used by this gum::Formula. More...
double	result () const
	Returns the result of this gum::Formula. More...
const std::string &	formula () const
	Returns the formula. More...
std::string &	formula ()
	Returns the formula. More...

Friends
class	gum::formula::Parser

Detailed Description

Evaluates a string as a algebraic formula.

Implementation of the Shunting-yard algorithm to convert infix notation to RPN. The gum::Formula::result() method implements the postfix algorithm to compute the formula result.

Warning

Checking is only done when evaluating the formula !

Definition at line 289 of file formula.h.

Constructor & Destructor Documentation

Formula() [1/13]

gum::Formula::Formula

(

short

s

)

Constructor.

Definition at line 187 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                          : _formula_(std::to_string(s)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [2/13]

gum::Formula::Formula

(

unsigned short

us

)

Constructor.

Definition at line 192 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                    : _formula_(std::to_string(us)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [3/13]

gum::Formula::Formula

(

int

i

)

Constructor.

Definition at line 197 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                        : _formula_(std::to_string(i)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [4/13]

gum::Formula::Formula

(

unsigned int

ui

)

Constructor.

Definition at line 202 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                  : _formula_(std::to_string(ui)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [5/13]

gum::Formula::Formula

(

long

l

)

Constructor.

Definition at line 207 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                         : _formula_(std::to_string(l)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [6/13]

gum::Formula::Formula

(

unsigned long

ul

)

Constructor.

Definition at line 212 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                   : _formula_(std::to_string(ul)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [7/13]

gum::Formula::Formula

(

long long

l

)

Constructor.

Definition at line 217 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                              : _formula_(std::to_string(l)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [8/13]

gum::Formula::Formula

(

unsigned long long

ul

)

Constructor.

Definition at line 222 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                        :
      _formula_(std::to_string(ul)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [9/13]

gum::Formula::Formula

(

float

f

)

Constructor.

Definition at line 228 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                          : _formula_(std::to_string(f)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [10/13]

gum::Formula::Formula

(

double

d

)

Constructor.

Definition at line 233 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                           : _formula_(std::to_string(d)), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);
    _initialise_();
  }

Here is the call graph for this function:

Formula() [11/13]

gum::Formula::Formula

(

const std::string &

f

)

Class constructor.

Parameters

f	An algebraic formula.

Definition at line 238 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                     : _formula_(f), _last_token_(FormulaPart()) {
    GUM_CONSTRUCTOR(Formula);

    _initialise_();
  }

Here is the call graph for this function:

Formula() [12/13]

gum::Formula::Formula

(

const Formula &

source

)

Copy constructor.

Parameters

source

The gum::Formula to copy.

Definition at line 244 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                        :
      _formula_(source._formula_), _last_token_(source._last_token_), _output_(source._output_),
      _stack_(source._stack_) {
    GUM_CONS_CPY(Formula);

    _initialise_();
  }

Here is the call graph for this function:

Formula() [13/13]

gum::Formula::Formula

(

Formula &&

source

)

Move constructor.

Parameters

source

The gum::Formula to move.

Definition at line 252 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                   :
      _formula_(std::move(source._formula_)), _scanner_(std::move(source._scanner_)),
      _parser_(std::move(source._parser_)), _last_token_(std::move(source._last_token_)),
      _output_(std::move(source._output_)), _stack_(std::move(source._stack_)) {
    GUM_CONS_CPY(Formula);

    _parser_->formula(this);
  }

Here is the call graph for this function:

~Formula()

gum::Formula::~Formula

(

)

Class destructor.

Definition at line 261 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                    {
    GUM_DESTRUCTOR(Formula);
    ;
  }

Here is the call graph for this function:

Member Function Documentation

_finalize_()

INLINE void gum::Formula::_finalize_ ( )

private

Finalize the formula and prepare it for evaluation.

Definition at line 340 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                           {
    while (!_stack_.empty()) {
      if (_stack_.top().character == '(') { GUM_ERROR(OperationNotAllowed, "expecting ')'") }

      _push_output_(_stack_.top());
      _stack_.pop();
    }
  }

Here is the call graph for this function:

_initialise_()

void gum::Formula::_initialise_ ( )

private

Initialise the formula scanner and parser.

Definition at line 177 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                             {
    auto c_str   = (unsigned char*)_formula_.c_str();
    auto scanner = new gum::formula::Scanner(c_str, (int)_formula_.size());
    _scanner_    = std::unique_ptr< gum::formula::Scanner >(scanner);

    auto parser = new gum::formula::Parser(scanner);
    _parser_    = std::unique_ptr< gum::formula::Parser >(parser);
    _parser_->formula(this);
  }

Here is the call graph for this function:

_isUnaryOperator_()

INLINE bool gum::Formula::_isUnaryOperator_ ( char  o )

private

Returns true if o is an unary operator.

Returns

Returns true if o is an unary operator.

Definition at line 275 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                        {
    switch (_last_token_.type) {
      case FormulaPart::token_type::OPERATOR:
      case FormulaPart::token_type::NIL:
      case FormulaPart::token_type::ARG_SEP: {
        return o == '-';
      }

      case FormulaPart::token_type::PARENTHESIS: {
        return (o == '-') && (_last_token_.character == '(');
      }

      default: {
        return false;
      }
    }
  }

Here is the call graph for this function:

_popOperator_()

INLINE bool gum::Formula::_popOperator_ ( FormulaPart  o )

private

Pop the operator in the inner formula's stack.

Parameters

o	The operator to pop.

Returns

Returns true if the operator was popped.

Definition at line 251 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                           {
    if (_stack_.empty() || _stack_.top().type != FormulaPart::token_type::OPERATOR) {
      return false;
    }

    if (o.isLeftAssociative() && o.precedence() <= _stack_.top().precedence()) { return true; }

    if (o.isRightAssociative() && o.precedence() < _stack_.top().precedence()) { return true; }

    return false;
  }

Here is the call graph for this function:

_push_comma_()

INLINE void gum::Formula::_push_comma_ ( )

private

Push a comma in the formula.

Definition at line 404 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                             {
    while ((!_stack_.empty()) && (_stack_.top().character != '(')) {
      _push_output_(_stack_.top());
      _stack_.pop();
    }

    if (_stack_.empty() || _stack_.top().character != '(') {
      GUM_ERROR(OperationNotAllowed, "expecting a '('")
    }

    _last_token_ = FormulaPart(FormulaPart::token_type::ARG_SEP, ',');
  }

Here is the call graph for this function:

_push_function_()

INLINE void gum::Formula::_push_function_ ( const std::string &  func )

private

Push a function in the formula.

Parameters

func	The function to push.

Definition at line 377 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                     {
    if (func == "exp") {
      FormulaPart t(FormulaPart::token_type::FUNCTION, FormulaPart::token_function::exp);
      _push_stack_(t);

    } else if (func == "log") {
      FormulaPart t(FormulaPart::token_type::FUNCTION, FormulaPart::token_function::log);
      _push_stack_(t);

    } else if (func == "ln") {
      FormulaPart t(FormulaPart::token_type::FUNCTION, FormulaPart::token_function::ln);
      _push_stack_(t);

    } else if (func == "pow") {
      FormulaPart t(FormulaPart::token_type::FUNCTION, FormulaPart::token_function::pow);
      _push_stack_(t);

    } else if (func == "sqrt") {
      FormulaPart t(FormulaPart::token_type::FUNCTION, FormulaPart::token_function::sqrt);
      _push_stack_(t);

    } else {
      GUM_ERROR(OperationNotAllowed, "unknown function")
    }
  }

Here is the call graph for this function:

_push_identifier_()

INLINE void gum::Formula::_push_identifier_ ( const std::string &  ident )

private

Use this if you don't know if ident is a function or a variable.

Definition at line 434 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                        {
    try {
      _push_function_(ident);

    } catch (OperationNotAllowed&) {
      try {
        _push_variable_(ident);

      } catch (OperationNotAllowed&) { GUM_ERROR(OperationNotAllowed, "unknown identifier") }
    }
  }

Here is the call graph for this function:

_push_leftParenthesis_()

INLINE void gum::Formula::_push_leftParenthesis_ ( )

private

Push a left parenthesis in the formula.

Definition at line 311 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                       {
    FormulaPart t(FormulaPart::token_type::PARENTHESIS, '(');
    _push_stack_(t);
  }

Here is the call graph for this function:

_push_number_()

INLINE void gum::Formula::_push_number_ ( const double &  v )

private

Push a number in the formula.

Parameters

v	The number to push.

Definition at line 245 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                             {
    FormulaPart t(FormulaPart::token_type::NUMBER, v);
    _push_output_(t);
  }

Here is the call graph for this function:

_push_operator_() [1/2]

INLINE void gum::Formula::_push_operator_ ( char  o )

private

Push an operator in the formula.

Parameters

o	The operator to push.

Definition at line 264 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                      {
    if (_isUnaryOperator_(o)) {
      _push_unaryOperator_(o);

    } else {
      FormulaPart t(FormulaPart::token_type::OPERATOR, o);
      _push_operator_(t);
    }
  }

Here is the call graph for this function:

_push_operator_() [2/2]

INLINE void gum::Formula::_push_operator_ ( FormulaPart  t )

private

Push an operator.

Parameters

t	The operator to push.

Definition at line 301 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                             {
    while (_popOperator_(t)) {
      _push_output_(_stack_.top());
      _stack_.pop();
    }

    _push_stack_(t);
  }

Here is the call graph for this function:

_push_output_()

INLINE void gum::Formula::_push_output_ ( FormulaPart  t )

private

Push the gum::FormulaPart in the output vector.

Parameters

t	The gum::FormulaPart to push.

Definition at line 365 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                           {
    _output_.push_back(t);
    _last_token_ = t;
  }

Here is the call graph for this function:

_push_rightParenthesis_()

INLINE void gum::Formula::_push_rightParenthesis_ ( )

private

Push a right parenthesis in the formula.

Definition at line 317 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                        {
    while ((!_stack_.empty()) && (_stack_.top().character != '(')) {
      _push_output_(_stack_.top());
      _stack_.pop();
    }

    if (_stack_.empty()) {
      GUM_ERROR(OperationNotAllowed, "expecting '('")

    } else if (_stack_.top().character != '(') {
      GUM_ERROR(OperationNotAllowed, "expecting '('")
    }

    _stack_.pop();

    if ((!_stack_.empty()) && _stack_.top().type == FormulaPart::token_type::FUNCTION) {
      _push_output_(_stack_.top());
      _stack_.pop();
    }
    _last_token_ = FormulaPart(FormulaPart::token_type::PARENTHESIS, ')');
  }

Here is the call graph for this function:

_push_stack_()

INLINE void gum::Formula::_push_stack_ ( FormulaPart  t )

private

Push the gum::FormulaPart in the stack.

Parameters

t	The gum::FormulaPart to push.

Definition at line 371 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                          {
    _stack_.push(t);
    _last_token_ = t;
  }

Here is the call graph for this function:

_push_unaryOperator_()

INLINE void gum::Formula::_push_unaryOperator_ ( char  o )

private

Push an unary operator.

Parameters

o	The unary operator to push.

Definition at line 294 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                           {
    // Only unary operator is the negative sign -
    FormulaPart t(FormulaPart::token_type::OPERATOR, '_');
    _push_operator_(t);
  }

Here is the call graph for this function:

_push_variable_()

INLINE void gum::Formula::_push_variable_ ( const std::string &  var )

private

Push a variable in the formula.

Definition at line 424 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                    {
    if (_variables_.exists(var)) {
      _push_number_(_variables_[var]);

    } else {
      GUM_ERROR(OperationNotAllowed, "unknonw variable")
    }
  }

Here is the call graph for this function:

_reduceOperatorOrFunction_()

INLINE void gum::Formula::_reduceOperatorOrFunction_ ( FormulaPart  item, std::stack< FormulaPart > &  stack  ) const

private

Evaluate an operator or function and push its result.

Parameters

item	The operator or function to reduce.
stack	The stack to evaluate.

Definition at line 350 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
    std::vector< FormulaPart > args;

    if (stack.size() < item.argc()) { GUM_ERROR(OperationNotAllowed, "not enought inputs ") }

    while (item.argc() > args.size()) {
      args.push_back(stack.top());
      stack.pop();
    }

    stack.push(item.eval(args));
  }

Here is the call graph for this function:

formula() [1/2]

INLINE const std::string & gum::Formula::formula

(

)

const

Returns the formula.

Definition at line 239 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return _formula_; }

Here is the call graph for this function:

formula() [2/2]

INLINE std::string & gum::Formula::formula

(

)

Returns the formula.

Definition at line 242 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return _formula_; }

Here is the call graph for this function:

operator double()

gum::Formula::operator double ( ) const

inlineexplicit

Allows implicit conversion to doubles.

Definition at line 360 of file formula.h.

{ return result(); }

operator=() [1/2]

Formula & gum::Formula::operator=

(

const Formula &

source

)

Copy operator.

Parameters

source

The gum::Formula to copy.

Returns

Returns this gum::Formula.

Definition at line 266 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                   {
    if (this == &source) { return *this; }

    _formula_    = source._formula_;
    _last_token_ = source._last_token_;
    _output_     = source._output_;
    _stack_      = source._stack_;

    _initialise_();

    return *this;
  }

Here is the call graph for this function:

operator=() [2/2]

Formula & gum::Formula::operator=

(

Formula &&

source

)

Move operator.

Parameters

source

The gum::Formula to move.

Returns

Returns this gum::Formula.

Definition at line 279 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                              {
    if (this == &source) { return *this; }

    _formula_ = std::move(source._formula_);
    _scanner_ = std::move(source._scanner_);
    _parser_  = std::move(source._parser_);
    _parser_->formula(this);
    _last_token_ = std::move(source._last_token_);
    _output_     = std::move(source._output_);
    _stack_      = std::move(source._stack_);

    return *this;
  }

Here is the call graph for this function:

result()

double gum::Formula::result

(

)

const

Returns the result of this gum::Formula.

Each call to Formula::result() will reevaluate the formulas result.

Returns

Returns the result of this gum::Formula.

Definition at line 293 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                               {
    _parser_->Parse();

    std::stack< FormulaPart > stack;
    if (_output_.empty()) { GUM_ERROR(OperationNotAllowed, "no output found") }

    for (auto item: _output_) {
      switch (item.type) {
        case FormulaPart::token_type::NUMBER: {
          stack.push(item);
          break;
        }

        case FormulaPart::token_type::OPERATOR:
        case FormulaPart::token_type::FUNCTION: {
          _reduceOperatorOrFunction_(item, stack);
          break;
        }

        default: {
          GUM_ERROR(OperationNotAllowed, "expecting numbers, operators or functions")
        }
      }
    }

    if (stack.size() != 1) {
      GUM_ERROR(OperationNotAllowed, "too many inputs")

    } else if (stack.top().type != FormulaPart::token_type::NUMBER) {
      GUM_ERROR(OperationNotAllowed, "too many inputs")
    }
    return stack.top().number;
  }

Here is the call graph for this function:

variables() [1/2]

INLINE HashTable< std::string, double > & gum::Formula::variables

(

)

Returns the variables used by this gum::Formula.

Returns

Returns the variables used by this gum::Formula.

Definition at line 418 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return _variables_; }

Here is the call graph for this function:

variables() [2/2]

INLINE const HashTable< std::string, double > & gum::Formula::variables

(

)

const

Returns the variables used by this gum::Formula.

Returns

Returns the variables used by this gum::Formula.

Definition at line 421 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return _variables_; }

Here is the call graph for this function:

Friends And Related Function Documentation

gum::formula::Parser

friend class gum::formula::Parser

friend

Definition at line 290 of file formula.h.

Member Data Documentation

_formula_

std::string gum::Formula::_formula_

private

The formula to evaluate.

Definition at line 457 of file formula.h.

_last_token_

FormulaPart gum::Formula::_last_token_

private

The last token added to the formula.

Definition at line 466 of file formula.h.

_output_

std::vector< FormulaPart > gum::Formula::_output_

private

The output stack, will contain one value after evaluation.

Definition at line 469 of file formula.h.

_parser_

std::unique_ptr< gum::formula::Parser > gum::Formula::_parser_

private

The parser used by the formula.

Definition at line 463 of file formula.h.

_scanner_

std::unique_ptr< gum::formula::Scanner > gum::Formula::_scanner_

private

The scanner used by the formula.

Definition at line 460 of file formula.h.

_stack_

std::stack< FormulaPart > gum::Formula::_stack_

private

A stack used during evaluation.

Definition at line 472 of file formula.h.

_variables_

HashTable< std::string, double > gum::Formula::_variables_

private

The variables available in this formula.

Definition at line 475 of file formula.h.

---

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

• agrum/tools/core/math/formula.h
• agrum/tools/core/math/formula.cpp
• agrum/tools/core/math/formula_inl.h