formula.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Christophe GONZALES and Pierre-Henri WUILLEMIN  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GUM_MATH_FORMULA_H
#define GUM_MATH_FORMULA_H

#include <iostream>
#include <list>
#include <memory>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

#include <agrum/agrum.h>
#include <agrum/core/hashTable.h>

namespace gum {

  namespace formula {
    class Scanner;
    class Parser;
  }   // namespace formula

  class FormulaPart {
    public:
    enum token_type { NUMBER, OPERATOR, PARENTHESIS, NIL, FUNCTION, ARG_SEP };

    enum token_function { exp, log, ln, pow, sqrt, nil };

    token_type type;

    double         number;
    char           character;
    token_function function;

    // ========================================================================
    // ========================================================================

    FormulaPart();

    FormulaPart(token_type t, double n);

    FormulaPart(token_type t, char c);

    FormulaPart(token_type t, token_function func);

    FormulaPart(const FormulaPart& source);

    FormulaPart(FormulaPart&& source);

    ~FormulaPart();

    // ========================================================================
    // ========================================================================

    FormulaPart& operator=(const FormulaPart& source);

    FormulaPart& operator=(FormulaPart&& source);

    // ========================================================================
    // ========================================================================

    std::string str() const;

    bool isLeftAssociative() const;

    bool isRightAssociative() const;

    int precedence() const;

    size_t argc() const;

    FormulaPart eval(const std::vector< FormulaPart >& args) const;


    private:
    double __operator_eval(const std::vector< FormulaPart >& args) const;

    double __function_eval(const std::vector< FormulaPart >& args) const;

    size_t __operator_argc() const;

    size_t __function_argc() const;
  };

  // extern class gum::formula::Parser;
  class Formula {
    friend class gum::formula::Parser;

    public:
    // ========================================================================
    // ========================================================================

    Formula(short s);
    Formula(unsigned short us);
    Formula(int i);
    Formula(unsigned int ui);
    Formula(long l);
    Formula(unsigned long ul);
    Formula(long long l);
    Formula(unsigned long long ul);
    Formula(float f);
    Formula(double d);

    Formula(const std::string& f);

    Formula(const Formula& source);

    Formula(Formula&& source);

    ~Formula();

    // ========================================================================
    // ========================================================================

    Formula& operator=(const Formula& source);

    Formula& operator=(Formula&& source);

    explicit operator double() const { return result(); }

    // ========================================================================
    // ========================================================================

    HashTable< std::string, double >& variables();

    const HashTable< std::string, double >& variables() const;

    double result() const;

    const std::string& formula() const;

    std::string& formula();

    private:
    // ========================================================================
    // ========================================================================

    void __push_number(const double& v);

    void __push_operator(char o);

    void __push_leftParenthesis();

    void __push_rightParenthesis();

    void __push_function(const std::string& func);

    void __push_variable(const std::string& var);

    void __push_identifier(const std::string& ident);

    void __push_comma();

    void __finalize();


    std::string __formula;

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

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

    FormulaPart __last_token;

    std::vector< FormulaPart > __output;

    std::stack< FormulaPart > __stack;

    HashTable< std::string, double > __variables;

    void __initialise();

    bool __popOperator(FormulaPart o);

    void __reduceOperatorOrFunction(FormulaPart                item,
                                    std::stack< FormulaPart >& stack) const;

    void __push_unaryOperator(char o);

    void __push_operator(FormulaPart t);

    bool __isUnaryOperator(char o);

    void __push_output(FormulaPart t);

    void __push_stack(FormulaPart t);
  };

  // // ========================================================================
  // /// @name Arithmetic Operators
  // // ========================================================================
  // /// @{

  Formula operator-(const Formula& a);

  Formula operator+(const Formula& a, const Formula& b);

  Formula operator-(const Formula& a, const Formula& b);

  Formula operator*(const Formula& a, const Formula& b);

  Formula operator/(const Formula& a, const Formula& b);

  std::string to_string(const Formula& f);

  std::ostream& operator<<(std::ostream& os, const Formula& f);

  // /// @}

} /* namespace gum */

#ifndef GUM_NO_INLINE
#  include <agrum/core/math/formula_inl.h>
#endif   // GUM_NO_INLINE

#endif /* GUM_MATH_FORMULA_H */