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

Private Member Functions
void	_initialise_ ()
	Initialise the formula scanner and parser.
bool	_popOperator_ (FormulaPart o)
	Pop the operator in the inner formula's stack.
void	_reduceOperatorOrFunction_ (FormulaPart item, std::stack< FormulaPart > &stack) const
	Evaluate an operator or function and push its result.
void	_push_unaryOperator_ (char o)
	Push an unary operator.
void	_push_operator_ (FormulaPart t)
	Push an operator.
bool	_isUnaryOperator_ (char o)
	Returns true if o is an unary operator.
void	_push_output_ (FormulaPart t)
	Push the gum::FormulaPart in the output vector.
void	_push_stack_ (FormulaPart t)
	Push the gum::FormulaPart in the stack.
Private accessors & modifiers used by the Formula Parser
void	_push_number_ (const double &v)
	Push a number in the formula.
void	_push_operator_ (char o)
	Push an operator in the formula.
void	_push_leftParenthesis_ ()
	Push a left parenthesis in the formula.
void	_push_rightParenthesis_ ()
	Push a right parenthesis in the formula.
void	_push_function_ (std::string_view func)
	Push a function in the formula.
void	_push_variable_ (std::string_view var)
	Push a variable in the formula.
void	_push_identifier_ (std::string_view ident)
	Use this if you don't know if ident is a function or a variable.
void	_push_comma_ ()
	Push a comma in the formula.
void	_finalize_ ()
	Finalize the formula and prepare it for evaluation.

Private Attributes
std::string	_formula_
	The formula to evaluate.
std::unique_ptr< gum::formula::Scanner >	_scanner_
	The scanner used by the formula.
std::unique_ptr< gum::formula::Parser >	_parser_
	The parser used by the formula.
FormulaPart	_last_token_
	The last token added to the formula.
std::vector< FormulaPart >	_output_
	The output stack, will contain one value after evaluation.
std::stack< FormulaPart >	_stack_
	A stack used during evaluation.
HashTable< std::string, double >	_variables_
	The variables available in this formula.

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 293 of file formula.h.

Constructor & Destructor Documentation

Formula() [1/13]

gum::Formula::Formula

(

short

s

)

Constructor.

Definition at line 198 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Referenced by Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), ~Formula(), gum::formula::Parser, operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

Formula() [2/13]

gum::Formula::Formula

(

unsigned short

us

)

Constructor.

Definition at line 203 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [3/13]

gum::Formula::Formula

(

int

i

)

Constructor.

Definition at line 208 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [4/13]

gum::Formula::Formula

(

unsigned int

ui

)

Constructor.

Definition at line 213 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [5/13]

gum::Formula::Formula

(

long

l

)

Constructor.

Definition at line 218 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [6/13]

gum::Formula::Formula

(

unsigned long

ul

)

Constructor.

Definition at line 223 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [7/13]

gum::Formula::Formula

(

long long

l

)

Constructor.

Definition at line 228 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [8/13]

gum::Formula::Formula

(

unsigned long long

ul

)

Constructor.

Definition at line 233 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [9/13]

gum::Formula::Formula

(

float

f

)

Constructor.

Definition at line 239 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

Here is the call graph for this function:

Formula() [10/13]

gum::Formula::Formula

(

double

d

)

Constructor.

Definition at line 244 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, and gum::to_string().

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 249 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), and _last_token_.

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 255 of file formula.cpp.

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

References Formula(), _formula_, _initialise_(), _last_token_, _output_, and _stack_.

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 263 of file formula.cpp.

                                   :
      _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);
  }

References Formula(), _formula_, _last_token_, _output_, _parser_, _scanner_, and _stack_.

Here is the call graph for this function:

~Formula()

gum::Formula::~Formula

(

)

Class destructor.

Definition at line 272 of file formula.cpp.

                    {
    GUM_DESTRUCTOR(Formula);
    ;
  }

References Formula().

Here is the call graph for this function:

Member Function Documentation

_finalize_()

void gum::Formula::_finalize_ ( )

private

Finalize the formula and prepare it for evaluation.

Definition at line 517 of file formula.cpp.

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

References _push_output_(), _stack_, and GUM_ERROR.

Here is the call graph for this function:

_initialise_()

void gum::Formula::_initialise_ ( )

private

Initialise the formula scanner and parser.

Definition at line 188 of file formula.cpp.

                             {
    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);
  }

References _formula_, _parser_, _scanner_, and gum::formula::Parser.

Referenced by Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), and operator=().

Here is the call graph for this function:

Here is the caller 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 113 of file formula_inl.h.

                                        {
    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;
      }
    }
  }

References _last_token_, gum::FormulaPart::ARG_SEP, gum::FormulaPart::NIL, gum::FormulaPart::OPERATOR, and gum::FormulaPart::PARENTHESIS.

Referenced by _push_operator_().

Here is the caller 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 89 of file formula_inl.h.

                                           {
    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;
  }

References _stack_, gum::FormulaPart::isLeftAssociative(), gum::FormulaPart::isRightAssociative(), gum::FormulaPart::OPERATOR, and gum::FormulaPart::precedence().

Referenced by _push_operator_().

Here is the call graph for this function:

Here is the caller graph for this function:

_push_comma_()

INLINE void gum::Formula::_push_comma_ ( )

private

Push a comma in the formula.

Definition at line 205 of file formula_inl.h.

                             {
    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, ',');
  }

References _last_token_, _push_output_(), _stack_, gum::FormulaPart::ARG_SEP, and GUM_ERROR.

Here is the call graph for this function:

_push_function_()

void gum::Formula::_push_function_ ( std::string_view func )

private

Push a function in the formula.

Parameters

func	The function to push.

Definition at line 526 of file formula.cpp.

                                                   {
    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")
    }
  }

References _push_stack_(), gum::FormulaPart::exp, gum::FormulaPart::FUNCTION, GUM_ERROR, gum::FormulaPart::ln, gum::FormulaPart::log, gum::FormulaPart::pow, and gum::FormulaPart::sqrt.

Referenced by _push_identifier_().

Here is the call graph for this function:

Here is the caller graph for this function:

_push_identifier_()

void gum::Formula::_push_identifier_ ( std::string_view ident )

private

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

Definition at line 552 of file formula.cpp.

                                                      {
    try {
      _push_function_(ident);
 
    } catch (OperationNotAllowed const&) {
      try {
        _push_variable_(ident);
 
      } catch (OperationNotAllowed const&) { GUM_ERROR(OperationNotAllowed, "unknown identifier") }
    }
  }

References _push_function_(), _push_variable_(), and GUM_ERROR.

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 149 of file formula_inl.h.

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

References _push_stack_(), and gum::FormulaPart::PARENTHESIS.

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 83 of file formula_inl.h.

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

References _push_output_(), and gum::FormulaPart::NUMBER.

Referenced by _push_variable_().

Here is the call graph for this function:

Here is the caller 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 102 of file formula_inl.h.

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

References _isUnaryOperator_(), _push_operator_(), _push_unaryOperator_(), and gum::FormulaPart::OPERATOR.

Referenced by _push_operator_(), and _push_unaryOperator_().

Here is the call graph for this function:

Here is the caller 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 139 of file formula_inl.h.

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

References _popOperator_(), _push_output_(), _push_stack_(), and _stack_.

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 193 of file formula_inl.h.

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

References _last_token_, and _output_.

Referenced by _finalize_(), _push_comma_(), _push_number_(), _push_operator_(), and _push_rightParenthesis_().

Here is the caller graph for this function:

_push_rightParenthesis_()

INLINE void gum::Formula::_push_rightParenthesis_ ( )

private

Push a right parenthesis in the formula.

Definition at line 155 of file formula_inl.h.

                                        {
    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, ')');
  }

References _last_token_, _push_output_(), _stack_, gum::FormulaPart::FUNCTION, GUM_ERROR, and gum::FormulaPart::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 199 of file formula_inl.h.

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

References _last_token_, and _stack_.

Referenced by _push_function_(), _push_leftParenthesis_(), and _push_operator_().

Here is the caller 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 132 of file formula_inl.h.

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

References _push_operator_(), and gum::FormulaPart::OPERATOR.

Referenced by _push_operator_().

Here is the call graph for this function:

Here is the caller graph for this function:

_push_variable_()

INLINE void gum::Formula::_push_variable_ ( std::string_view var )

private

Push a variable in the formula.

Definition at line 225 of file formula_inl.h.

                                                  {
    if (_variables_.exists(var)) {
      _push_number_(_variables_[var]);
 
    } else {
      GUM_ERROR(OperationNotAllowed, "unknonw variable")
    }
  }

References _push_number_(), _variables_, and GUM_ERROR.

Referenced by _push_identifier_().

Here is the call graph for this function:

Here is the caller 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 178 of file formula_inl.h.

                                                                                 {
    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));
  }

References gum::FormulaPart::argc(), gum::FormulaPart::eval(), and GUM_ERROR.

Referenced by result().

Here is the call graph for this function:

Here is the caller graph for this function:

formula() [1/2]

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

(

)

Returns the formula.

Definition at line 80 of file formula_inl.h.

{ return _formula_; }

References _formula_.

formula() [2/2]

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

(

)

const

Returns the formula.

Args are backwards !

Args are backwards ! Args are backwards !

Definition at line 77 of file formula_inl.h.

{ return _formula_; }

References _formula_.

operator double()

INLINE gum::Formula::operator double ( ) const

explicit

Allows implicit conversion to doubles.

Definition at line 271 of file formula_inl.h.

{ return result(); }

References result().

Here is the call graph for this function:

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 277 of file formula.cpp.

                                                 {
    if (this == &source) { return *this; }
 
    _formula_    = source._formula_;
    _last_token_ = source._last_token_;
    _output_     = source._output_;
    _stack_      = source._stack_;
 
    _initialise_();
 
    return *this;
  }

References Formula(), _formula_, _initialise_(), _last_token_, _output_, and _stack_.

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 290 of file formula.cpp.

                                            {
    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;
  }

References Formula(), _formula_, _last_token_, _output_, _parser_, _scanner_, and _stack_.

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 304 of file formula.cpp.

                               {
    _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;
  }

References _output_, _parser_, _reduceOperatorOrFunction_(), gum::FormulaPart::FUNCTION, GUM_ERROR, gum::FormulaPart::NUMBER, and gum::FormulaPart::OPERATOR.

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::_fillCpf_(), operator double(), gum::operator*(), gum::operator+(), gum::operator-(), gum::operator-(), gum::operator/(), gum::operator<<(), and gum::to_string().

Here is the call graph for this function:

Here is the caller 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 219 of file formula_inl.h.

{ return _variables_; }

References _variables_.

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::_fillCpf_().

Here is the caller 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 222 of file formula_inl.h.

{ return _variables_; }

References _variables_.

Friends And Related Symbol Documentation

gum::formula::Parser

friend class gum::formula::Parser

friend

Definition at line 294 of file formula.h.

References Formula(), and gum::formula::Parser.

Referenced by _initialise_(), and gum::formula::Parser.

Member Data Documentation

_formula_

std::string gum::Formula::_formula_

private

The formula to evaluate.

Definition at line 461 of file formula.h.

Referenced by Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), _initialise_(), formula(), formula(), operator=(), and operator=().

_last_token_

FormulaPart gum::Formula::_last_token_

private

The last token added to the formula.

Definition at line 470 of file formula.h.

Referenced by Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), Formula(), _isUnaryOperator_(), _push_comma_(), _push_output_(), _push_rightParenthesis_(), _push_stack_(), operator=(), and operator=().

_output_

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

private

The output stack, will contain one value after evaluation.

Definition at line 473 of file formula.h.

Referenced by Formula(), Formula(), _push_output_(), operator=(), operator=(), and result().

_parser_

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

private

The parser used by the formula.

Definition at line 467 of file formula.h.

Referenced by Formula(), _initialise_(), operator=(), and result().

_scanner_

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

private

The scanner used by the formula.

Definition at line 464 of file formula.h.

Referenced by Formula(), _initialise_(), and operator=().

_stack_

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

private

A stack used during evaluation.

Definition at line 476 of file formula.h.

Referenced by Formula(), Formula(), _finalize_(), _popOperator_(), _push_comma_(), _push_operator_(), _push_rightParenthesis_(), _push_stack_(), operator=(), and operator=().

_variables_

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

private

The variables available in this formula.

Definition at line 479 of file formula.h.

Referenced by _push_variable_(), variables(), and variables().

---

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

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