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_ (const std::string &func)
	Push a function in the formula.
void	_push_variable_ (const std::string &var)
	Push a variable in the formula.
void	_push_identifier_ (const std::string &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 207 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 212 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 217 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 222 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 227 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 232 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 237 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 242 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 248 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 253 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 258 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 264 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 272 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 281 of file formula.cpp.

                    {
    GUM_DESTRUCTOR(Formula);
    ;
  }

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

                           {
    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 197 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 296 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 272 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 425 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_()

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

                                                     {
    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_()

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

                                                        {
    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 332 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 266 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 285 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 322 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 386 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 338 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 392 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 315 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_ ( const std::string & var )

private

Push a variable in the formula.

Definition at line 445 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 371 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 263 of file formula_inl.h.

{ return _formula_; }

References _formula_.

formula() [2/2]

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

(

)

const

Returns the formula.

Definition at line 260 of file formula_inl.h.

{ return _formula_; }

References _formula_.

operator double()

gum::Formula::operator double ( ) const

inlineexplicit

Allows implicit conversion to doubles.

Definition at line 364 of file formula.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 286 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 299 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 313 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 439 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 442 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