formula.h

Go to the documentation of this file.

/****************************************************************************
 *   This file is part of the aGrUM/pyAgrum library.                        *
 *                                                                          *
 *   Copyright (c) 2005-2025 by                                             *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *                                                                          *
 *   The aGrUM/pyAgrum library is free software; you can redistribute it    *
 *   and/or modify it under the terms of either :                           *
 *                                                                          *
 *    - the GNU Lesser General Public License as published by               *
 *      the Free Software Foundation, either version 3 of the License,      *
 *      or (at your option) any later version,                              *
 *    - the MIT license (MIT),                                              *
 *    - or both in dual license, as here.                                   *
 *                                                                          *
 *   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    *
 *                                                                          *
 *   This aGrUM/pyAgrum library is distributed in the hope that it will be  *
 *   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          *
 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
 *   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   *
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  *
 *   OTHER DEALINGS IN THE SOFTWARE.                                        *
 *                                                                          *
 *   See LICENCES for more details.                                         *
 *                                                                          *
 *   SPDX-FileCopyrightText: Copyright 2005-2025                            *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      *
 *                                                                          *
 *   Contact  : info_at_agrum_dot_org                                       *
 *   homepage : http://agrum.gitlab.io                                      *
 *   gitlab   : https://gitlab.com/agrumery/agrum                           *
 *                                                                          *
 ****************************************************************************/
 

#ifndef GUM_MATH_FORMULA_H
#define GUM_MATH_FORMULA_H
 
#include <iostream>
#include <list>
#include <memory>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
 
#include <agrum/agrum.h>
 
#include <agrum/base/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/base/core/math/formula_inl.h>
#endif   // GUM_NO_INLINE
 
#endif   /* GUM_MATH_FORMULA_H */