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 274 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 __initialise().

                          :
      __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 193 of file formula.cpp.

References __initialise().

                                    :
      __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 199 of file formula.cpp.

References __initialise().

                        :
      __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 205 of file formula.cpp.

References __initialise().

                                  :
      __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 211 of file formula.cpp.

References __initialise().

                         :
      __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 217 of file formula.cpp.

References __initialise().

                                   :
      __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 223 of file formula.cpp.

References __initialise().

                              :
      __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 229 of file formula.cpp.

References __initialise().

                                        :
      __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 235 of file formula.cpp.

References __initialise().

                          :
      __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 241 of file formula.cpp.

References __initialise().

                           :
      __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 247 of file formula.cpp.

References __initialise().

                                     :
      __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 254 of file formula.cpp.

References __initialise().

                                        :
      __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 262 of file formula.cpp.

References __parser.

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

~Formula()

gum::Formula::~Formula

(

)

Class destructor.

Definition at line 272 of file formula.cpp.

{ GUM_DESTRUCTOR(Formula); }

Member Function Documentation

__finalize()

INLINE void gum::Formula::__finalize ( )

private

Finalize the formula and prepare it for evaluation.

Definition at line 349 of file formula_inl.h.

References GUM_ERROR.

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

      __push_output(__stack.top());
      __stack.pop();
    }
  }

__initialise()

void gum::Formula::__initialise ( )

private

Initialise the formula scanner and parser.

Definition at line 177 of file formula.cpp.

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

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

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

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

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

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

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

References GUM_ERROR.

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

__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.

References GUM_ERROR.

                                                        {
    try {
      __push_function(ident);

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

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

__push_leftParenthesis()

INLINE void gum::Formula::__push_leftParenthesis ( )

private

Push a left parenthesis in the formula.

Definition at line 319 of file formula_inl.h.

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

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

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

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

                                      {
    if (__isUnaryOperator(o)) {
      __push_unaryOperator(o);

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

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

                                             {
    while (__popOperator(t)) {
      __push_output(__stack.top());
      __stack.pop();
    }

    __push_stack(t);
  }

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

                                           {
    __output.push_back(t);
    __last_token = t;
  }

__push_rightParenthesis()

INLINE void gum::Formula::__push_rightParenthesis ( )

private

Push a right parenthesis in the formula.

Definition at line 325 of file formula_inl.h.

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

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

                                          {
    __stack.push(t);
    __last_token = t;
  }

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

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

__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.

References GUM_ERROR.

                                                    {
    if (__variables.exists(var)) {
      __push_number(__variables[var]);

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

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

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

Referenced by result().

                                                                               {
    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:

Here is the caller graph for this function:

formula() [1/2]

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

(

)

const

Returns the formula.

Definition at line 242 of file formula_inl.h.

{ return __formula; }

formula() [2/2]

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

(

)

Returns the formula.

Definition at line 245 of file formula_inl.h.

{ return __formula; }

operator double()

gum::Formula::operator double ( ) const

inlineexplicit

Allows implicit conversion to doubles.

Definition at line 345 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 274 of file formula.cpp.

References __formula, __initialise(), __last_token, __output, and __stack.

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

References __formula, __last_token, __output, __parser, __scanner, and __stack.

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

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

References __output, __parser, __reduceOperatorOrFunction(), and GUM_ERROR.

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

                               {
    __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:

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

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

{ return __variables; }

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

                                                                 {
    return __variables;
  }

Friends And Related Function Documentation

gum::formula::Parser

friend class gum::formula::Parser

friend

Definition at line 275 of file formula.h.

Member Data Documentation

__formula

std::string gum::Formula::__formula

private

The formula to evaluate.

Definition at line 442 of file formula.h.

Referenced by operator=().

__last_token

FormulaPart gum::Formula::__last_token

private

The last token added to the formula.

Definition at line 451 of file formula.h.

Referenced by operator=().

__output

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

private

The output stack, will contain one value after evaluation.

Definition at line 454 of file formula.h.

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

__parser

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

private

The parser used by the formula.

Definition at line 448 of file formula.h.

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

__scanner

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

private

The scanner used by the formula.

Definition at line 445 of file formula.h.

Referenced by operator=().

__stack

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

private

A stack used during evaluation.

Definition at line 457 of file formula.h.

Referenced by operator=().

__variables

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

private

The variables available in this formula.

Definition at line 460 of file formula.h.

---

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

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